diff --git a/.cargo/config.toml b/.cargo/config.toml
index 7572155938..ecfed438e2 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -26,10 +26,10 @@ test_details = "test --target aarch64-apple-darwin"
 # native crate needs no change here. Axum (native), Cloudflare
 # (wasm32-unknown-unknown), Spin, the CLI (native), and integration-tests
 # (native) are simply not listed.
-build-fastly = "build -p trusted-server-core -p trusted-server-adapter-fastly -p trusted-server-device-fastly -p trusted-server-geo-fastly -p trusted-server-cmp-osano -p trusted-server-modules -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-sellers -p trusted-server-headers-geo -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-mock -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb -p trusted-server-js -p trusted-server-openrtb --target wasm32-wasip1"
-check-fastly = "check -p trusted-server-core -p trusted-server-adapter-fastly -p trusted-server-device-fastly -p trusted-server-geo-fastly -p trusted-server-cmp-osano -p trusted-server-modules -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-sellers -p trusted-server-headers-geo -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-mock -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb -p trusted-server-js -p trusted-server-openrtb --target wasm32-wasip1"
-clippy-fastly = "clippy -p trusted-server-core -p trusted-server-adapter-fastly -p trusted-server-device-fastly -p trusted-server-geo-fastly -p trusted-server-cmp-osano -p trusted-server-modules -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-sellers -p trusted-server-headers-geo -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-mock -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb -p trusted-server-js -p trusted-server-openrtb --all-targets --all-features --target wasm32-wasip1 -- -D warnings"
-test-fastly = "test -p trusted-server-core -p trusted-server-adapter-fastly -p trusted-server-device-fastly -p trusted-server-geo-fastly -p trusted-server-cmp-osano -p trusted-server-modules -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-sellers -p trusted-server-headers-geo -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-mock -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb -p trusted-server-js -p trusted-server-openrtb --target wasm32-wasip1"
+build-fastly = "build -p trusted-server-core -p trusted-server-adapter-fastly -p trusted-server-device-fastly -p trusted-server-geo-fastly -p trusted-server-cmp-osano -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-iabtl -p trusted-server-headers-geo -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-iabtl -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb -p trusted-server-js -p trusted-server-openrtb --target wasm32-wasip1"
+check-fastly = "check -p trusted-server-core -p trusted-server-adapter-fastly -p trusted-server-device-fastly -p trusted-server-geo-fastly -p trusted-server-cmp-osano -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-iabtl -p trusted-server-headers-geo -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-iabtl -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb -p trusted-server-js -p trusted-server-openrtb --target wasm32-wasip1"
+clippy-fastly = "clippy -p trusted-server-core -p trusted-server-adapter-fastly -p trusted-server-device-fastly -p trusted-server-geo-fastly -p trusted-server-cmp-osano -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-iabtl -p trusted-server-headers-geo -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-iabtl -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb -p trusted-server-js -p trusted-server-openrtb --all-targets --all-features --target wasm32-wasip1 -- -D warnings"
+test-fastly = "test -p trusted-server-core -p trusted-server-adapter-fastly -p trusted-server-device-fastly -p trusted-server-geo-fastly -p trusted-server-cmp-osano -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-iabtl -p trusted-server-headers-geo -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-iabtl -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb -p trusted-server-js -p trusted-server-openrtb --target wasm32-wasip1"
 # Feature-on counterpart of `test-fastly`. `test-fastly` does NOT pass
 # --all-features, so without this the reusable-sandbox code is linted by
 # `clippy-fastly` but its tests never execute.
@@ -40,8 +40,8 @@ test-fastly-reuse = "test -p trusted-server-adapter-fastly --target wasm32-wasip
 # run with the Axum adapter in CI.
 build-axum = "build -p trusted-server-adapter-axum"
 check-axum = "check -p trusted-server-adapter-axum"
-clippy-axum = "clippy -p trusted-server-adapter-axum -p trusted-server-permission-signal-gpc -p trusted-server-permission-signal-gpp -p trusted-server-permission-signal-mtm -p trusted-server-permission-signal-tcf -p trusted-server-permission-signal-us-privacy -p trusted-server-cmp-osano -p trusted-server-modules -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-sellers -p trusted-server-headers-geo -p trusted-server-loading-cache-51degrees -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-mock -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb --all-targets --all-features -- -D warnings"
-test-axum = "test -p trusted-server-adapter-axum -p trusted-server-permission-signal-gpc -p trusted-server-permission-signal-gpp -p trusted-server-permission-signal-mtm -p trusted-server-permission-signal-tcf -p trusted-server-permission-signal-us-privacy -p trusted-server-cmp-osano -p trusted-server-modules -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-sellers -p trusted-server-headers-geo -p trusted-server-loading-cache-51degrees -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-mock -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb"
+clippy-axum = "clippy -p trusted-server-adapter-axum -p trusted-server-permission-signal-gpc -p trusted-server-permission-signal-gpp -p trusted-server-permission-signal-mtm -p trusted-server-permission-signal-tcf -p trusted-server-permission-signal-us-privacy -p trusted-server-cmp-osano -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-iabtl -p trusted-server-headers-geo -p trusted-server-loading-cache-51degrees -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-iabtl -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb --all-targets --all-features -- -D warnings"
+test-axum = "test -p trusted-server-adapter-axum -p trusted-server-permission-signal-gpc -p trusted-server-permission-signal-gpp -p trusted-server-permission-signal-mtm -p trusted-server-permission-signal-tcf -p trusted-server-permission-signal-us-privacy -p trusted-server-cmp-osano -p trusted-server-identity-lockr -p trusted-server-audience-permutive -p trusted-server-cmp-sourcepoint -p trusted-server-cmp-didomi -p trusted-server-cmp-inmobi -p trusted-server-ads-txt-iabtl -p trusted-server-headers-geo -p trusted-server-loading-cache-51degrees -p trusted-server-asset-cache-51degrees -p trusted-server-tag-google-tag -p trusted-server-tag-google-tag-manager -p trusted-server-testing-testlight -p trusted-server-framework-nextjs -p trusted-server-ad-tag-google -p trusted-server-bot-protection-datadome -p trusted-server-ad-server-iabtl -p trusted-server-auction-aps -p trusted-server-auction-prebid -p trusted-server-auction-prebid-server -p trusted-server-auction-protocol-openrtb"
 
 # --- Cloudflare adapter (native host + wasm32-unknown-unknown) ---
 # Build/check target the WASM runtime (requires the `cloudflare` feature);
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 757dd12565..2f6384152f 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -126,13 +126,13 @@ jobs:
         run: |
           cargo test --package trusted-server-core --target "$(rustc -vV | sed -n 's/host: //p')"
 
-      # The seam-probe fixture crate's own unit tests only run when invoked on
+      # The seam probe fixture crate's own unit tests only run when invoked on
       # the host target, because no adapter alias compiles its test target. Run
       # them here so a fault in the seam fixture cannot sit unseen behind a
       # green gate set.
-      - name: Run host-target seam-probe integration tests
+      - name: Run host-target seam probe integration tests
         run: |
-          cargo test --package trusted-server-integration-seam-probe --target "$(rustc -vV | sed -n 's/host: //p')"
+          cargo test --package trusted-server-testing-iabtl --target "$(rustc -vV | sed -n 's/host: //p')"
 
       - name: Verify Fastly WASM release build
         run: cargo build --package trusted-server-adapter-fastly --release --target wasm32-wasip1
diff --git a/AGENTS.md b/AGENTS.md
index 91a946fabd..b1f641b043 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -21,9 +21,8 @@ crates/
   trusted-server-adapter-cloudflare/    # Cloudflare Workers entry point (wasm32-unknown-unknown binary)
   trusted-server-adapter-spin/          # Fermyon Spin entry point (wasm32-wasip1 component)
   trusted-server-cli/                   # Host-target `ts` operator CLI
-  trusted-server-modules/               # the modules a stock build ships, in the order their hooks run
-  ad-server/                            # ad server implementation crates (mock)
-  ads-txt/                              # ads.txt line module crates (sellers)
+  ad-server/                            # ad server implementation crates (iabtl)
+  ads-txt/                              # ads.txt line module crates (iabtl)
   ad-tag/                               # ad tag module crates (google, which holds its diagnostics module too)
   auction/                              # auction module crates (aps, prebid, prebid-server)
   audience/                             # audience module crates (permutive)
@@ -32,7 +31,7 @@ crates/
   framework/                            # framework module crates (nextjs)
   identity/                             # identity module crates (lockr)
   tag/                                  # tag module crates (google-tag, google-tag-manager)
-  testing/                              # test module crates (seam-probe, testlight)
+  testing/                              # test module crates (iabtl, testlight)
   device/
     fastly/                             # trusted-server-device-fastly (opt-in TLS/H2 device module)
   edgecookie/                           # vendor Edge Cookie module crates (built-in HMAC module is in core)
@@ -412,10 +411,10 @@ to read before changing any module configuration.
 | Geo / IP intelligence | `PlatformGeo` (`platform/traits.rs`)                  | `[geo] module`                                                                                                                                                                                                           | None, no location (the default), or `platform`                                                                                                                                                                                                                                         | `crates/geo/<vendor>`               |
 | Permission signals    | `PermissionSignalModule` (`permission_signal/mod.rs`) | `[permission-signal] modules` (an ordered list)                                                                                                                                                                          | `gpc`, `gpp`, `us-privacy`, `tcf`, all of them with no list                                                                                                                                                                                                                            | `crates/permission-signal/<scheme>` |
 | Auction demand        | `DemandImplementation` (`auction/demand.rs`)          | `[demand] modules` (a list)                                                                                                                                                                                              | `auction-protocol.openrtb`, `auction.prebid-server`, `auction.aps`                                                                                                                                                                                                                     | an integration builder              |
-| Ad server             | `AdServerImplementation` (`auction/demand.rs`)        | `[ad-server] module`                                                                                                                                                                                                     | `mock` (`ad-server.mock`)                                                                                                                                                                                                                                                              | an integration builder              |
+| Ad server             | `AdServerImplementation` (`auction/demand.rs`)        | `[ad-server] module`                                                                                                                                                                                                     | `iabtl` (`ad-server.iabtl`)                                                                                                                                                                                                                                                            | an integration builder              |
 | Page integrations     | `IntegrationBuilder` (`integrations/mod.rs`)          | the section of the module's type: `[cmp] module`, `[tag] modules`, `[ad-tag] modules`, `[bot-protection] module`, `[identity] module`, `[audience] module`, `[framework] module`, `[auction] modules`, `[proxy] modules` | `cmp.didomi`, `cmp.sourcepoint`, `cmp.osano`, `tag.google-tag`, `tag.google-tag-manager`, `ad-tag.google`, `ad-tag.google.diagnostics`, `bot-protection.datadome`, `identity.lockr`, `audience.permutive`, `framework.nextjs`, `auction.prebid`, `testing.testlight`, `js_asset_proxy` | an adapter-supplied builder         |
 
-`auction-protocol.openrtb`, `auction.prebid-server`, `auction.aps` and `ad-server.mock` supply implementations
+`auction-protocol.openrtb`, `auction.prebid-server`, `auction.aps` and `ad-server.iabtl` supply implementations
 only. No module section selects them.
 
 Principles for adding or changing a module:
@@ -454,8 +453,8 @@ IntegrationRegistration::builder(ID)
 ```
 
 - Integration IDs match JS directory names: `prebid` (deferred), `lockr`, `permutive`, `datadome`, `didomi`, `testlight`.
-- An integration runs when the section of its type selects its module. A module with a crate of its own is named by that crate's path under `crates/` (`permission-signal.gpc`, `testing.seam-probe`). Each page integration lives in a crate of its own and holds that name in a `MODULE` constant (`cmp.didomi`, `tag.google-tag`, `tag.google-tag-manager`, `ad-tag.google`, `bot-protection.datadome`, `identity.lockr`, `audience.permutive`, `framework.nextjs`, `auction.prebid`, `testing.testlight`), which a test in the crate holds to the crate's folder. A name is written in its section with the type left off. There is no `enabled` flag and no `[integration]` table.
-- `creative` is JS-only (no Rust registration), and `nextjs` is Rust-only. `auction-protocol.openrtb`, `auction.prebid-server`, `auction.aps` and `ad-server.mock` register demand or ad server implementations rather than page integrations.
+- An integration runs when the section of its type selects its module. A module with a crate of its own is named by that crate's path under `crates/` (`permission-signal.gpc`, `testing.iabtl`). Each page integration lives in a crate of its own and holds that name in a `MODULE` constant (`cmp.didomi`, `tag.google-tag`, `tag.google-tag-manager`, `ad-tag.google`, `bot-protection.datadome`, `identity.lockr`, `audience.permutive`, `framework.nextjs`, `auction.prebid`, `testing.testlight`), which a test in the crate holds to the crate's folder. A name is written in its section with the type left off. There is no `enabled` flag and no `[integration]` table.
+- `creative` is JS-only (no Rust registration), and `nextjs` is Rust-only. `auction-protocol.openrtb`, `auction.prebid-server`, `auction.aps` and `ad-server.iabtl` register demand or ad server implementations rather than page integrations.
 - Integrations opt into deferred loading via `.with_deferred_js()` on the registration builder. Deferred modules are served as separate `<script defer>` tags instead of being concatenated into the main bundle.
 - `IntegrationRegistry::js_module_ids_immediate()` returns modules for the main bundle; `js_module_ids_deferred()` returns modules loaded with `defer`.
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5be75ba496..b9fb20e06e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- **Breaking:** The ad server this repository ships is `ad-server.iabtl`, from `crates/ad-server/iabtl` as the package `trusted-server-ad-server-iabtl`, where it was `ad-server.mock` from `crates/ad-server/mock`. A deployment that selected it writes `[ad-server] module = "iabtl"` and `[ad-server.iabtl]` where it wrote `module = "mock"` and `[ad-server.mock]`, and an `implementation = "ad-server.mock"` line names `ad-server.iabtl`. The seam probe, the test fixture that proves the integration seam from outside core, is `crates/testing/iabtl` as the package `trusted-server-testing-iabtl`, selected as `testing.iabtl`, where it was `crates/testing/seam-probe` selected as `testing.seam-probe`, with its shared table `[shared.iabtl]`, its loading cache `loading-cache.iabtl` and its declared cache `iabtl-answers` named the same way. The module that adds sellers to `ads.txt` is `ads-txt.iabtl`, from `crates/ads-txt/iabtl` as the package `trusted-server-ads-txt-iabtl`, where it was `ads-txt.sellers` from `crates/ads-txt/sellers`. A deployment that selected it writes `[ads-txt] modules = ["iabtl"]` and `[ads-txt.iabtl]` where it wrote `modules = ["sellers"]` and `[ads-txt.sellers]`, and the `[[fetch]]` entry on `/ads.txt` names the middleware `ads-txt.iabtl` where it named `ads-txt.sellers`. Each module describes the middleware it supplies on its builder with `IntegrationBuilder::with_middleware`, as `SuppliedMiddleware` values naming the middleware, the phase an entry names it in and the media type the entry covers, and `trusted_server_core::integrations::supplied_middleware(builders)` lists what a build supplies in the order the registry registers them, core's robots.txt and service version middleware included. The registry refuses a registration whose middleware contradicts its builder's description, in a phase it does not run in or for a media type it does not work on. **Breaking for crates outside core:** `crates/trusted-server-modules` is gone. Each adapter lists the module builders it links in its own `app.rs`, as `shipped_module_builders()`, with `module_builders_with(extra)` putting a deployment's builders after them, and the `ts` tool lists the builders it links and writes its entries and a module's section from what they describe. A deployment that took its list from `trusted_server_modules::builders()` or `builders_with(...)` names the crates it links instead, or takes an adapter's list.
 - **Breaking for crates outside core:** the consent decoders live in the crates named for their standards. The TCF string decoder is in `trusted-server-permission-signal-tcf`, the GPP string decoder in `trusted-server-permission-signal-gpp`, and the US Privacy string decoder in `trusted-server-permission-signal-us-privacy`, and each module reads its own string from the request through `PermissionSignalModule::read`, once, and reports a `SignalRecord`. `ConsentContext` is the records the configured modules reported and the request's jurisdiction, read by scheme name, with nothing of any standard in it, and a reader that needs a string in its standard's own form asks that standard's crate (`tc_string`, `applies`, `gpp_string`, `section_ids`, `us_privacy_string`, `signaled`). A record also carries the permissions its signal consents to, and the server-side auction gate keeps its rule by reading them, so in a GDPR or unknown jurisdiction, or where a record says its regulation applies, the auction needs consent to device storage (TCF Purpose 1) from a record that applies. Without `tcf` in the modules no TC String is read, and one that cannot be read, standalone or in a GPP string, is no consent to any purpose TCF maps. `[consent]` keeps its keys, with `mode` parsed by core and the rest read by the modules, and `signals.<scheme>.authoritative` in `permissions.yaml` is read for any scheme. The identity graph record writes every vouched signal under its scheme, in the shape it wrote before for the two it stored. `CONSENT_COOKIE_NAMES`, `forward_cookie_header`, the consent cookie and header constants, `ConsentForwardingMode` (now the Prebid Server crate's), the `GdprConsent` error and the never-filled Additional Consent field and `additional_consent` policy flag are removed.
 - **Breaking for crates outside core:** the identifiers a request carries come from identifier modules. Core declares `IdentifierModule` in `trusted_server_core::ec::identifiers`, a registration offers one with `IntegrationRegistrationBuilder::with_identifier_module`, and core asks every running module once per request, when it reads the Edge Cookie state, then syncs the answers to the identity graph and carries them to the auction as it did the `ts-eids` cookie. The Prebid module owns that cookie, its two shapes and its size limit, and is the first identifier module. `COOKIE_EIDS` is removed from core, `ec_finalize_response` no longer takes the cookie's value, `EcContext::module_eids` holds what the modules learned, and `RuntimeServices` carries the modules through `with_identifier_modules`. A `template_cache_key_cookies` entry naming any cookie under the public prefix is refused, where the Edge Cookie and the EIDs cookie were refused by name. A deployment's settings do not change.
 - **Breaking:** The React Server Components Flight rewriter is the middleware `framework.nextjs.flight` of the Next.js module, which runs on a `text/x-component` response where a `[[fetch]]` entry names it, where core rewrote every Flight response by media type. A deployment that fronts a Next.js site selects `[framework] module = "nextjs"` and adds the entry, as `trusted-server.example.toml` shows it. With the module selected and no entry, a Flight response passes through as the origin sent it, and an entry may now cover `text/x-component`. A middleware says with `Middleware::moves_origin_address` that it moves the origin's address itself, and core then leaves the addresses in a body of the media types it handles to it, whether or not an entry names it, because a plain replacement in a length prefixed row leaves the old length. **For crates outside core**, `trusted_server_core::rsc_flight` is removed.
@@ -40,7 +41,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Breaking:** A module's change to a page runs only on the pages where a `[[fetch]]` or `[[serve]]` entry names its middleware. A deployment adds the entries when it upgrades. Until it does, a module changes no page, and startup logs a warning naming each middleware that no entry names. "Placing page changes" in the configuration guide lists the middleware each module supplies and the phase each runs in. To keep a page as it was, name the middleware of the modules a deployment selects in one `[[fetch]]` entry and one `[[serve]]` entry for `text/html`, in the order `trusted-server.example.toml` shows them, which is the order the modules' hooks ran in.
 - **Breaking:** The four page traits are removed, being `IntegrationAttributeRewriter`, `IntegrationScriptRewriter`, `IntegrationHtmlStreamProcessorFactory` and `IntegrationHeadInjector`, with their context types, `ScriptTextAccumulator`, `AttributeRewriteOutcome` and the registration methods that took them. A module that implemented one supplies a `Middleware` instead, whose action carries the same decisions. A browser module's attribute on the script bundle's tag is stated with `with_bundle_tag_attribute`.
 - A pushed configuration keeps DataDome's two deprecated secret store selectors, `server_side_key_secret_store` and `protection_test_bypass.credential_secret_store`, where they were removed as the settings were read. DataDome still accepts and discards both, so a configuration that carries one loads as before.
-- Integration modules have moved out of `trusted-server-core` into crates of their own under `crates/<type>/<vendor>/`, each named by that folder, so `crates/cmp/osano` is the module `cmp.osano`. The settings that select and configure a module do not change. `crates/trusted-server-modules` lists the modules a stock build ships from crates of their own, in the order their hooks run. Every adapter builds its state and loads its settings with that list, and `ts config validate` and `ts config push` run each stock module's own rules. Code that named a moved module under `trusted_server_core::integrations` names its crate instead, such as `trusted_server_cmp_osano`. Moved: Osano, Lockr, Permutive, Sourcepoint, Didomi, Google Tag Manager, Testlight, Next.js, Google Publisher Tags and its diagnostics, DataDome, the mock ad server, APS, Prebid, the Prebid Server demand and the plain OpenRTB demand. Core keeps the JavaScript asset proxy, which is its own.
+- Integration modules have moved out of `trusted-server-core` into crates of their own under `crates/<type>/<vendor>/`, each named by that folder, so `crates/cmp/osano` is the module `cmp.osano`. The settings that select and configure a module do not change. Each adapter lists the modules a stock build ships from crates of their own, in the order their hooks run. Every adapter builds its state and loads its settings with that list, and `ts config validate` and `ts config push` run each stock module's own rules. Code that named a moved module under `trusted_server_core::integrations` names its crate instead, such as `trusted_server_cmp_osano`. Moved: Osano, Lockr, Permutive, Sourcepoint, Didomi, Google Tag Manager, Testlight, Next.js, Google Publisher Tags and its diagnostics, DataDome, the mock ad server, APS, Prebid, the Prebid Server demand and the plain OpenRTB demand. Core keeps the JavaScript asset proxy, which is its own.
 - The Fastly adapter is a library with a thin binary over it. A deployment that ships a vendor crate writes a binary of its own that calls `trusted_server_adapter_fastly::run_with(vec![...])` with that crate's integration builder, in place of editing the adapter. The builders are composed with the built-in ones, and a builder runs only when the settings select its module. The Wasm artifact keeps its name, `trusted-server-adapter-fastly.wasm`.
 - **Breaking:** `[integrations]` is gone. Each page integration is a module selected in the section of its type, with its settings in the table at its name: `[cmp] module = "didomi"` (or `"sourcepoint"` or `"osano"`), `[tag] modules = ["google-tag-manager"]`, `[ad-tag] modules = ["google", "google.diagnostics"]`, `[bot-protection] module = "datadome"`, `[identity] module = "lockr"`, `[audience] module = "permutive"`, `[framework] module = "nextjs"`, `[auction] modules = ["prebid"]` (with `"testing.testlight"` for the test module) and `[proxy] modules = ["js_asset_proxy"]`, so `[integrations.gpt]` is `[ad-tag.google]` and `[integrations.prebid]` is `[auction.prebid]`. A module's name is `<type>.<name>`, which is its crate's path under `crates/`, and it is written in its section with the type left off. A section that selects nothing, a table its section does not select, and a name no module in the deployment supplies are each refused at startup. An `[integrations]` or `[integration]` table is refused with directions. Environment overlays name a section as written, so `TRUSTED_SERVER__INTEGRATIONS__GPT__GAM_ATTRIBUTION_ENABLED` is `TRUSTED_SERVER__AD-TAG__GOOGLE__GAM_ATTRIBUTION_ENABLED`.
 - **Breaking:** Every pluggable component now shares one configuration syntax. Each selectable type is a top-level table named for the job, a `module` key inside it selects what runs, or `modules` for a type that runs several, and a `[<type>.<name>]` table holds that name's settings when it has any. The types are `ec`, `geo`, `device`, `permission-signal`, `demand` and `ad-server`, and the section of each page integration type, such as `cmp` or `tag`. A module from a crate is named by its folder below `crates/`, such as `permission-signal.gpc`, and within its own table the type folder may be left off. A `demand` or `ad-server` name is snake_case, because it may be a label of your own. A settings table its type's selector does not name refuses startup, so a block left behind after a module is switched off is caught rather than sitting unread, and every module rejects settings it does not know, so a misspelled key fails rather than being ignored. A table's name is the implementation unless the table carries an `implementation` line, and a demand table always carries one, naming the implementation by its module path (`auction-protocol.openrtb`, `auction.prebid-server` or `auction.aps`), which is how two Prebid Servers run side by side under names of their own. The ad server implementation is `ad-server.mock`, written `mock` in `[ad-server]`. A `demand` or `ad-server` endpoint must be HTTPS, or HTTP to `127.0.0.1`, `::1` or `localhost`. The word mediator is gone. It is "ad server" in prose and `ad-server` in configuration, `[debug.auction_html_comment_options] include_mediator_response` is now `include_adserver_response`, and the auction response metadata value `parallel_mediation` is now `parallel_adserver`. `auction-protocol.openrtb`, `auction.prebid-server`, `auction.aps` and `ad-server.mock` supply implementations only, so a page integration's section that names one is refused. The full rules and what is checked at each gate are in [Configuration Rules](docs/guide/configuration-rules.md). Migrate as follows:
@@ -146,7 +147,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `ts keys rotate` and `ts keys deactivate` rotate and retire the request signing keys from an operator's machine. They write the two stores the service links as `jwks_store` and `signing_keys` through the `fastly` CLI, with the token from `FASTLY_API_TOKEN`. A private key reaches `fastly` on its standard input and never in its arguments, and a key id no platform can store is refused before anything is written. A command that cannot read the config store writes nothing, and a delete that failed part way can be run again.
 - A deployment may address a request by its path before its configuration is chosen, so one host serves several publishers, each under a path of its own and from its own app-config blob. It supplies a `RequestAddressing` from `trusted_server_core::addressing`, through `trusted_server_adapter_fastly::run_with_addressing` or `TrustedServerApp::routes_with_addressing` on the other adapters. The hook answers either that a request is addressed by its host, as before, or the selector values that take the place of `{host}`, the path the request continues with and the prefix it removed. The first value whose blob exists is read and a miss on every value is answered `421`, never from a key the hook did not name. The request is routed at the continuing path with its query kept, and carries the prefix as a `RemovedPathPrefix` extension, which a deployment's own middleware puts back into its pages. Adapters that read one blob ignore the values. With no hook every request is served as before.
 - One Fastly service can serve several publishers. A `TS__CONFIG__KEY` entry in the `trusted_server_config` store that contains `{host}` names an app-config blob for each host, pushed with `ts config push --key <host>`, and each request reads the blob under its own host. Each host's blob names its permission policy file and pins its SHA-256, and the push keeps each file `--permissions` supplies once, in a shared entry under `permissions_<sha256>`, written before the blob, which a live push writes a minute after it writes an entry. A host with no blob is answered `421 Misdirected Request`, never from the logical store ID or from another host's blob, a malformed selector is answered `500`, and a sandbox that serves several requests keeps an application for each blob, found only by that blob's key. Without the entry, or with a selector that has no placeholder, the service reads one blob. `scripts/config-by-host-local-test.sh` runs it under Viceroy.
-- `ts audit generate` writes the `[[fetch]]` and `[[serve]]` entries that run the page changes of the modules it selects on every HTML page, and `trusted-server.example.toml` documents the entries with every middleware the stock modules supply. `trusted-server-modules` lists those middleware with `middleware()` and `middleware_for(...)`.
+- `ts audit generate` writes the `[[fetch]]` and `[[serve]]` entries that run the page changes of the modules it selects on every HTML page, and `trusted-server.example.toml` documents the entries with every middleware the stock modules supply. Core lists those middleware with `supplied_middleware(builders)`.
 - Page changes as middleware. A module registers a change it makes to a page with `.with_middleware(...)`, and the ordered `[[fetch]]` and `[[serve]]` entries of the settings say which pages each one runs on and in what order. A fetch middleware runs on the page as the origin sent it and what it writes is stored with a shared template. A serve middleware runs on each reader's copy, whether the page came from the store or from the origin, and nothing it writes is stored. Where text a middleware writes into a script would end the script, or begin `<script` after `<!--`, its `<` is written as `\u003c`. An entry with no path after one with `path = "/"` is refused, because both cover every page.
 - A builder registers its module from the compiled auction plan with `with_plan_registration` and checks its settings against the plan with `with_plan_validator`, so a module whose page support follows what the plan selects is not named in `trusted-server-core`. Prebid and APS register this way. A renderer descriptor carries its builder's statement of which payload key holds the identifier the renderer picks its bid by, made with `BidRenderer::picking_bid_by`, and the page's `hb_adid` is read through that statement.
 - A module declares the settings in its own table that hold the name of a secret, with `with_secret_settings` on its builder, each with a rule for when the table puts it to use. A setting in use is looked up in the default secret store as the settings load and has to name a key for deploy validation to pass, and one not in use is cleared and never looked up. DataDome's server-side key and its test bypass credential are declared this way, and `trusted-server-core` no longer names them.
diff --git a/Cargo.lock b/Cargo.lock
index 7ee0185180..cc0f8bdf78 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -6587,7 +6587,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "trusted-server-ad-server-mock"
+name = "trusted-server-ad-server-iabtl"
 version = "0.1.0"
 dependencies = [
  "async-trait",
@@ -6641,14 +6641,32 @@ dependencies = [
  "tempfile",
  "tokio",
  "tower 0.4.13",
+ "trusted-server-ad-server-iabtl",
+ "trusted-server-ad-tag-google",
+ "trusted-server-ads-txt-iabtl",
+ "trusted-server-auction-aps",
+ "trusted-server-auction-prebid",
+ "trusted-server-auction-prebid-server",
+ "trusted-server-auction-protocol-openrtb",
+ "trusted-server-audience-permutive",
+ "trusted-server-bot-protection-datadome",
+ "trusted-server-cmp-didomi",
+ "trusted-server-cmp-inmobi",
+ "trusted-server-cmp-osano",
+ "trusted-server-cmp-sourcepoint",
  "trusted-server-core",
- "trusted-server-integration-seam-probe",
- "trusted-server-modules",
+ "trusted-server-framework-nextjs",
+ "trusted-server-headers-geo",
+ "trusted-server-identity-lockr",
  "trusted-server-permission-signal-gpc",
  "trusted-server-permission-signal-gpp",
  "trusted-server-permission-signal-mtm",
  "trusted-server-permission-signal-tcf",
  "trusted-server-permission-signal-us-privacy",
+ "trusted-server-tag-google-tag",
+ "trusted-server-tag-google-tag-manager",
+ "trusted-server-testing-iabtl",
+ "trusted-server-testing-testlight",
 ]
 
 [[package]]
@@ -6667,15 +6685,33 @@ dependencies = [
  "serde_json",
  "tokio",
  "toml",
+ "trusted-server-ad-server-iabtl",
+ "trusted-server-ad-tag-google",
+ "trusted-server-ads-txt-iabtl",
+ "trusted-server-auction-aps",
+ "trusted-server-auction-prebid",
+ "trusted-server-auction-prebid-server",
+ "trusted-server-auction-protocol-openrtb",
+ "trusted-server-audience-permutive",
+ "trusted-server-bot-protection-datadome",
+ "trusted-server-cmp-didomi",
+ "trusted-server-cmp-inmobi",
+ "trusted-server-cmp-osano",
+ "trusted-server-cmp-sourcepoint",
  "trusted-server-core",
- "trusted-server-integration-seam-probe",
+ "trusted-server-framework-nextjs",
+ "trusted-server-headers-geo",
+ "trusted-server-identity-lockr",
  "trusted-server-js",
- "trusted-server-modules",
  "trusted-server-permission-signal-gpc",
  "trusted-server-permission-signal-gpp",
  "trusted-server-permission-signal-mtm",
  "trusted-server-permission-signal-tcf",
  "trusted-server-permission-signal-us-privacy",
+ "trusted-server-tag-google-tag",
+ "trusted-server-tag-google-tag-manager",
+ "trusted-server-testing-iabtl",
+ "trusted-server-testing-testlight",
  "worker",
 ]
 
@@ -6699,16 +6735,34 @@ dependencies = [
  "serde",
  "serde_json",
  "toml",
+ "trusted-server-ad-server-iabtl",
+ "trusted-server-ad-tag-google",
+ "trusted-server-ads-txt-iabtl",
+ "trusted-server-auction-aps",
+ "trusted-server-auction-prebid",
+ "trusted-server-auction-prebid-server",
+ "trusted-server-auction-protocol-openrtb",
+ "trusted-server-audience-permutive",
+ "trusted-server-bot-protection-datadome",
+ "trusted-server-cmp-didomi",
+ "trusted-server-cmp-inmobi",
+ "trusted-server-cmp-osano",
+ "trusted-server-cmp-sourcepoint",
  "trusted-server-core",
  "trusted-server-device-fastly",
+ "trusted-server-framework-nextjs",
  "trusted-server-geo-fastly",
- "trusted-server-integration-seam-probe",
- "trusted-server-modules",
+ "trusted-server-headers-geo",
+ "trusted-server-identity-lockr",
  "trusted-server-permission-signal-gpc",
  "trusted-server-permission-signal-gpp",
  "trusted-server-permission-signal-mtm",
  "trusted-server-permission-signal-tcf",
  "trusted-server-permission-signal-us-privacy",
+ "trusted-server-tag-google-tag",
+ "trusted-server-tag-google-tag-manager",
+ "trusted-server-testing-iabtl",
+ "trusted-server-testing-testlight",
  "urlencoding",
 ]
 
@@ -6731,19 +6785,37 @@ dependencies = [
  "serde_json",
  "spin-sdk",
  "tokio",
+ "trusted-server-ad-server-iabtl",
+ "trusted-server-ad-tag-google",
+ "trusted-server-ads-txt-iabtl",
+ "trusted-server-auction-aps",
+ "trusted-server-auction-prebid",
+ "trusted-server-auction-prebid-server",
+ "trusted-server-auction-protocol-openrtb",
+ "trusted-server-audience-permutive",
+ "trusted-server-bot-protection-datadome",
+ "trusted-server-cmp-didomi",
+ "trusted-server-cmp-inmobi",
+ "trusted-server-cmp-osano",
+ "trusted-server-cmp-sourcepoint",
  "trusted-server-core",
- "trusted-server-integration-seam-probe",
+ "trusted-server-framework-nextjs",
+ "trusted-server-headers-geo",
+ "trusted-server-identity-lockr",
  "trusted-server-js",
- "trusted-server-modules",
  "trusted-server-permission-signal-gpc",
  "trusted-server-permission-signal-gpp",
  "trusted-server-permission-signal-mtm",
  "trusted-server-permission-signal-tcf",
  "trusted-server-permission-signal-us-privacy",
+ "trusted-server-tag-google-tag",
+ "trusted-server-tag-google-tag-manager",
+ "trusted-server-testing-iabtl",
+ "trusted-server-testing-testlight",
 ]
 
 [[package]]
-name = "trusted-server-ads-txt-sellers"
+name = "trusted-server-ads-txt-iabtl"
 version = "0.1.0"
 dependencies = [
  "error-stack",
@@ -6939,10 +7011,26 @@ dependencies = [
  "toml",
  "toml_edit 0.23.10+spec-1.0.0",
  "tracing",
+ "trusted-server-ad-server-iabtl",
+ "trusted-server-ad-tag-google",
+ "trusted-server-ads-txt-iabtl",
+ "trusted-server-auction-aps",
  "trusted-server-auction-prebid",
  "trusted-server-auction-prebid-server",
+ "trusted-server-auction-protocol-openrtb",
+ "trusted-server-audience-permutive",
+ "trusted-server-bot-protection-datadome",
+ "trusted-server-cmp-didomi",
+ "trusted-server-cmp-inmobi",
+ "trusted-server-cmp-osano",
+ "trusted-server-cmp-sourcepoint",
  "trusted-server-core",
- "trusted-server-modules",
+ "trusted-server-framework-nextjs",
+ "trusted-server-headers-geo",
+ "trusted-server-identity-lockr",
+ "trusted-server-tag-google-tag",
+ "trusted-server-tag-google-tag-manager",
+ "trusted-server-testing-testlight",
  "url",
  "uuid",
  "webpki-roots",
@@ -7123,25 +7211,6 @@ dependencies = [
  "validator",
 ]
 
-[[package]]
-name = "trusted-server-integration-seam-probe"
-version = "0.1.0"
-dependencies = [
- "async-trait",
- "bytes",
- "edgezero-core",
- "error-stack",
- "hex",
- "http",
- "log",
- "serde",
- "serde_json",
- "sha2 0.11.1",
- "tokio",
- "trusted-server-core",
- "validator",
-]
-
 [[package]]
 name = "trusted-server-integration-tests"
 version = "0.1.0"
@@ -7171,7 +7240,6 @@ dependencies = [
  "trusted-server-adapter-cloudflare",
  "trusted-server-adapter-spin",
  "trusted-server-core",
- "trusted-server-modules",
  "urlencoding",
 ]
 
@@ -7200,36 +7268,6 @@ dependencies = [
  "web-time",
 ]
 
-[[package]]
-name = "trusted-server-modules"
-version = "0.1.0"
-dependencies = [
- "edgezero-core",
- "http",
- "serde_json",
- "tokio",
- "trusted-server-ad-server-mock",
- "trusted-server-ad-tag-google",
- "trusted-server-ads-txt-sellers",
- "trusted-server-auction-aps",
- "trusted-server-auction-prebid",
- "trusted-server-auction-prebid-server",
- "trusted-server-auction-protocol-openrtb",
- "trusted-server-audience-permutive",
- "trusted-server-bot-protection-datadome",
- "trusted-server-cmp-didomi",
- "trusted-server-cmp-inmobi",
- "trusted-server-cmp-osano",
- "trusted-server-cmp-sourcepoint",
- "trusted-server-core",
- "trusted-server-framework-nextjs",
- "trusted-server-headers-geo",
- "trusted-server-identity-lockr",
- "trusted-server-tag-google-tag",
- "trusted-server-tag-google-tag-manager",
- "trusted-server-testing-testlight",
-]
-
 [[package]]
 name = "trusted-server-openrtb"
 version = "0.1.0"
@@ -7339,6 +7377,25 @@ dependencies = [
  "validator",
 ]
 
+[[package]]
+name = "trusted-server-testing-iabtl"
+version = "0.1.0"
+dependencies = [
+ "async-trait",
+ "bytes",
+ "edgezero-core",
+ "error-stack",
+ "hex",
+ "http",
+ "log",
+ "serde",
+ "serde_json",
+ "sha2 0.11.1",
+ "tokio",
+ "trusted-server-core",
+ "validator",
+]
+
 [[package]]
 name = "trusted-server-testing-testlight"
 version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index 08a5524274..d24029afd2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,7 @@ members = [
     # workspace member so it shares workspace settings and lints; no default
     # member and no adapter build reaches it, and only the Axum and Fastly
     # adapters' tests depend on it.
-    "crates/testing/seam-probe",
+    "crates/testing/iabtl",
     "crates/permission-signal/gpc",
     "crates/permission-signal/gpp",
     "crates/permission-signal/mtm",
@@ -19,7 +19,7 @@ members = [
     "crates/cmp/sourcepoint",
     "crates/cmp/didomi",
     "crates/cmp/inmobi",
-    "crates/ads-txt/sellers",
+    "crates/ads-txt/iabtl",
     "crates/headers/geo",
     "crates/loading-cache/51degrees",
     "crates/asset-cache/51degrees",
@@ -29,7 +29,7 @@ members = [
     "crates/framework/nextjs",
     "crates/ad-tag/google",
     "crates/bot-protection/datadome",
-    "crates/ad-server/mock",
+    "crates/ad-server/iabtl",
     "crates/auction/aps",
     "crates/auction/prebid",
     "crates/auction/prebid-server",
@@ -42,7 +42,6 @@ members = [
     "crates/trusted-server-core",
     "crates/trusted-server-integration-tests",
     "crates/trusted-server-js",
-    "crates/trusted-server-modules",
     "crates/trusted-server-openrtb",
     # Manual protobuf codegen tool — a member so it shares workspace settings,
     # but no default member or alias builds it. Run it explicitly with `-p`.
@@ -170,7 +169,7 @@ trusted-server-audience-permutive = { path = "crates/audience/permutive" }
 trusted-server-cmp-sourcepoint = { path = "crates/cmp/sourcepoint" }
 trusted-server-cmp-didomi = { path = "crates/cmp/didomi" }
 trusted-server-cmp-inmobi = { path = "crates/cmp/inmobi" }
-trusted-server-ads-txt-sellers = { path = "crates/ads-txt/sellers" }
+trusted-server-ads-txt-iabtl = { path = "crates/ads-txt/iabtl" }
 trusted-server-headers-geo = { path = "crates/headers/geo" }
 trusted-server-loading-cache-51degrees = { path = "crates/loading-cache/51degrees" }
 trusted-server-asset-cache-51degrees = { path = "crates/asset-cache/51degrees" }
@@ -180,13 +179,12 @@ trusted-server-testing-testlight = { path = "crates/testing/testlight" }
 trusted-server-framework-nextjs = { path = "crates/framework/nextjs" }
 trusted-server-ad-tag-google = { path = "crates/ad-tag/google" }
 trusted-server-bot-protection-datadome = { path = "crates/bot-protection/datadome" }
-trusted-server-ad-server-mock = { path = "crates/ad-server/mock" }
+trusted-server-ad-server-iabtl = { path = "crates/ad-server/iabtl" }
 trusted-server-auction-aps = { path = "crates/auction/aps" }
 trusted-server-auction-prebid = { path = "crates/auction/prebid" }
 trusted-server-auction-prebid-server = { path = "crates/auction/prebid-server" }
 trusted-server-auction-protocol-openrtb = { path = "crates/auction-protocol/openrtb" }
 trusted-server-js = { path = "crates/trusted-server-js" }
-trusted-server-modules = { path = "crates/trusted-server-modules" }
 trusted-server-openrtb = { path = "crates/trusted-server-openrtb" }
 url = "2.5.8"
 urlencoding = "2.1"
diff --git a/TESTING.md b/TESTING.md
index 8ebafe0a18..254fd6a8a6 100644
--- a/TESTING.md
+++ b/TESTING.md
@@ -40,9 +40,9 @@ debug = false
 module = "pbs_main"
 
 [ad-server]
-module = "mock"
+module = "iabtl"
 
-[ad-server.mock]
+[ad-server.iabtl]
 endpoint = "https://adserver.example.com/decide"
 timeout_ms = 500
 ```
diff --git a/crates/ad-server/mock/Cargo.toml b/crates/ad-server/iabtl/Cargo.toml
similarity index 96%
rename from crates/ad-server/mock/Cargo.toml
rename to crates/ad-server/iabtl/Cargo.toml
index aa122197ce..79703f00ec 100644
--- a/crates/ad-server/mock/Cargo.toml
+++ b/crates/ad-server/iabtl/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "trusted-server-ad-server-mock"
+name = "trusted-server-ad-server-iabtl"
 description = "The demonstration ad server, which asks mocktioneer's decision endpoint to pick the winning bid, as an ad server module."
 authors = { workspace = true }
 edition = { workspace = true }
diff --git a/crates/ad-server/mock/src/lib.rs b/crates/ad-server/iabtl/src/lib.rs
similarity index 99%
rename from crates/ad-server/mock/src/lib.rs
rename to crates/ad-server/iabtl/src/lib.rs
index f32ff7e7ad..9286d8f6a3 100644
--- a/crates/ad-server/mock/src/lib.rs
+++ b/crates/ad-server/iabtl/src/lib.rs
@@ -1,4 +1,4 @@
-//! The demonstration ad server implementation, `ad-server.mock`.
+//! The demonstration ad server implementation, `ad-server.iabtl`.
 //!
 //! It calls mocktioneer's decision endpoint, which picks the winning bid by
 //! price, so a deployment can exercise the ad server seam without a real ad
@@ -49,8 +49,8 @@ use trusted_server_core::platform::{PlatformHttpRequest, PlatformResponse, Runti
 // ============================================================================
 
 /// The name this implementation is selected by, its module path, which
-/// `[ad-server]` shortens to `mock`. It also serves as its builder's id.
-pub const MODULE: &str = "ad-server.mock";
+/// `[ad-server]` shortens to `iabtl`. It also serves as its builder's id.
+pub const MODULE: &str = "ad-server.iabtl";
 
 /// The demonstration ad server implementation.
 pub static ADSERVER: AdServerImplementation = AdServerImplementation { id: MODULE, build };
@@ -106,7 +106,7 @@ pub struct AdServerMockSettings {
     /// to the ad server decision endpoint without hard-coding integration knowledge.
     ///
     /// ```toml
-    /// [ad-server.mock.context_query_params]
+    /// [ad-server.iabtl.context_query_params]
     /// permutive_segments = "permutive"
     /// ```
     #[serde(default)]
diff --git a/crates/ad-tag/google/src/diagnostics.rs b/crates/ad-tag/google/src/diagnostics.rs
index 29cc5d2cf6..cc9443b4e9 100644
--- a/crates/ad-tag/google/src/diagnostics.rs
+++ b/crates/ad-tag/google/src/diagnostics.rs
@@ -32,6 +32,14 @@ pub const GPT_DIAGNOSTICS_INTEGRATION_ID: &str = "gpt_diagnostics";
 /// The name this module is selected by, in `[ad-tag]`.
 pub const MODULE: &str = "ad-tag.google.diagnostics";
 
+/// The page change the module supplies, as an entry names it.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Serve,
+    ),
+];
+
 /// The builder a deployment hands to an adapter, which the registry runs when
 /// a section selects [`MODULE`].
 #[must_use]
@@ -46,6 +54,7 @@ pub fn builder() -> IntegrationBuilder {
     .with_request_preparer(prepare_request_hook)
     .with_response_finalizer(finalize_response_hook)
     .with_auction_token()
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 /// Reserved activation query parameter.
@@ -945,4 +954,18 @@ mod tests {
             "should write nothing into a document diagnostics is not active for: {processed}"
         );
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[crate::builder(), super::builder()],
+            super::builder().id(),
+        );
+    }
 }
diff --git a/crates/ad-tag/google/src/lib.rs b/crates/ad-tag/google/src/lib.rs
index 6388c3699f..977a49c909 100644
--- a/crates/ad-tag/google/src/lib.rs
+++ b/crates/ad-tag/google/src/lib.rs
@@ -96,6 +96,18 @@ pub const MODULE: &str = "ad-tag.google";
 /// permissions allow storage on the device.
 pub const LOADER_MIDDLEWARE: &str = "ad-tag.google.loader";
 
+/// The page changes the module supplies, as entries name them.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        LOADER_MIDDLEWARE,
+        trusted_server_core::middleware::MiddlewarePhase::Serve,
+    ),
+];
+
 /// The builder a deployment hands to an adapter, which the registry runs when
 /// a section selects [`MODULE`].
 #[must_use]
@@ -107,6 +119,7 @@ pub fn builder() -> trusted_server_core::integrations::IntegrationBuilder {
         validate,
     )
     .with_module_name(MODULE)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 /// Primary Google domain that serves GPT scripts.
@@ -2026,4 +2039,18 @@ mod tests {
             ),
         );
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder(), super::diagnostics::builder()],
+            super::builder().id(),
+        );
+    }
 }
diff --git a/crates/ads-txt/sellers/Cargo.toml b/crates/ads-txt/iabtl/Cargo.toml
similarity index 94%
rename from crates/ads-txt/sellers/Cargo.toml
rename to crates/ads-txt/iabtl/Cargo.toml
index 48f16ca1f8..ba67557f56 100644
--- a/crates/ads-txt/sellers/Cargo.toml
+++ b/crates/ads-txt/iabtl/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "trusted-server-ads-txt-sellers"
+name = "trusted-server-ads-txt-iabtl"
 description = "Adds a publisher's sellers to the origin's ads.txt from the lines the settings give, or makes the file from them where the origin has none."
 authors = { workspace = true }
 edition = { workspace = true }
diff --git a/crates/ads-txt/sellers/src/fixtures/sellers.settings.toml b/crates/ads-txt/iabtl/src/fixtures/sellers.settings.toml
similarity index 68%
rename from crates/ads-txt/sellers/src/fixtures/sellers.settings.toml
rename to crates/ads-txt/iabtl/src/fixtures/sellers.settings.toml
index 1d4b71bcd8..6385d0ea6c 100644
--- a/crates/ads-txt/sellers/src/fixtures/sellers.settings.toml
+++ b/crates/ads-txt/iabtl/src/fixtures/sellers.settings.toml
@@ -1,10 +1,10 @@
 [ads-txt]
-modules = ["sellers"]
+modules = ["iabtl"]
 
-[ads-txt.sellers]
+[ads-txt.iabtl]
 lines = ["ssp.example, 12345, DIRECT, f08c47fec0942fa0", "CONTACT=ads@publisher.example"]
 
 [[fetch]]
 media_type = "text/plain"
 path = "/ads.txt"
-middleware = ["ads-txt.sellers"]
+middleware = ["ads-txt.iabtl"]
diff --git a/crates/ads-txt/sellers/src/lib.rs b/crates/ads-txt/iabtl/src/lib.rs
similarity index 91%
rename from crates/ads-txt/sellers/src/lib.rs
rename to crates/ads-txt/iabtl/src/lib.rs
index 6d6437384e..afe4126fe4 100644
--- a/crates/ads-txt/sellers/src/lib.rs
+++ b/crates/ads-txt/iabtl/src/lib.rs
@@ -22,8 +22,16 @@ const SELLERS_INTEGRATION_ID: &str = "ads_txt_sellers";
 
 /// The name `[ads-txt] modules` selects the module by and a `[[fetch]]` entry
 /// names its middleware by, from this crate's folder. Its settings are the
-/// table `[ads-txt.sellers]`.
-pub const MODULE: &str = "ads-txt.sellers";
+/// table `[ads-txt.iabtl]`.
+pub const MODULE: &str = "ads-txt.iabtl";
+
+/// The change to the file the module supplies, as an entry on the file's path names it.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] =
+    &[trusted_server_core::integrations::SuppliedMiddleware::on(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+        MEDIA_TYPE,
+    )];
 
 /// The media type an `ads.txt` is served as, and the one the middleware
 /// works on.
@@ -124,7 +132,7 @@ fn check_line(line: &str) -> Result<(), String> {
 fn validate_lines(config: &SellersConfig) -> Result<(), Report<TrustedServerError>> {
     if config.lines.is_empty() {
         return Err(Report::new(TrustedServerError::Settings {
-            message: "`lines` in [ads-txt.sellers] is empty, so the module would add nothing. \
+            message: "`lines` in [ads-txt.iabtl] is empty, so the module would add nothing. \
                       Give the lines to add, or do not select the module"
                 .to_owned(),
         }));
@@ -133,7 +141,7 @@ fn validate_lines(config: &SellersConfig) -> Result<(), Report<TrustedServerErro
         if let Err(problem) = check_line(line) {
             return Err(Report::new(TrustedServerError::Settings {
                 message: format!(
-                    "`lines` in [ads-txt.sellers], line {}, `{}`, {problem}",
+                    "`lines` in [ads-txt.iabtl], line {}, `{}`, {problem}",
                     index + 1,
                     line.trim()
                 ),
@@ -157,7 +165,7 @@ fn require_an_entry(settings: &Settings) -> Result<(), Report<TrustedServerError
     }
     Err(Report::new(TrustedServerError::Settings {
         message: format!(
-            "[ads-txt] selects `sellers`, but no [[fetch]] entry for `{MEDIA_TYPE}` with path \
+            "[ads-txt] selects `iabtl`, but no [[fetch]] entry for `{MEDIA_TYPE}` with path \
              = `{PATH}` names `{MODULE}`, so the lines would never be written into the file or \
              make it where the origin has none. Add an entry with media_type = \
              `{MEDIA_TYPE}`, path = `{PATH}` and the middleware. The path is a prefix, so the \
@@ -213,6 +221,7 @@ pub fn builder() -> IntegrationBuilder {
         validate,
     )
     .with_module_name(MODULE)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 /// The lines written at the end of the file, as the middleware adds them.
@@ -299,9 +308,9 @@ mod tests {
     fn settings_with(lines: &[&str]) -> Settings {
         let quoted: Vec<String> = lines.iter().map(|line| format!("\"{line}\"")).collect();
         page_settings(&format!(
-            "[ads-txt]\nmodules = [\"sellers\"]\n\n[ads-txt.sellers]\nlines = [{}]\n\n\
+            "[ads-txt]\nmodules = [\"iabtl\"]\n\n[ads-txt.iabtl]\nlines = [{}]\n\n\
              [[fetch]]\nmedia_type = \"text/plain\"\npath = \"/ads.txt\"\n\
-             middleware = [\"ads-txt.sellers\"]\n",
+             middleware = [\"ads-txt.iabtl\"]\n",
             quoted.join(", ")
         ))
     }
@@ -396,14 +405,14 @@ mod tests {
     #[test]
     fn a_document_naming_the_module_in_no_entry_is_refused() {
         let settings = page_settings(&format!(
-            "[ads-txt]\nmodules = [\"sellers\"]\n\n[ads-txt.sellers]\nlines = [\"{RECORD}\"]\n"
+            "[ads-txt]\nmodules = [\"iabtl\"]\n\n[ads-txt.iabtl]\nlines = [\"{RECORD}\"]\n"
         ));
 
         let refused = validate(&settings).expect_err("should refuse a module no entry places");
         assert!(
             format!("{refused:?}").contains(
                 "no [[fetch]] entry for `text/plain` with path = `/ads.txt` names \
-                 `ads-txt.sellers`"
+                 `ads-txt.iabtl`"
             ),
             "{refused:?}"
         );
@@ -415,16 +424,16 @@ mod tests {
         for path in [None, Some("/robots.txt"), Some("/ads"), Some("/")] {
             let path_line = path.map_or_else(String::new, |path| format!("path = \"{path}\"\n"));
             let settings = page_settings(&format!(
-                "[ads-txt]\nmodules = [\"sellers\"]\n\n[ads-txt.sellers]\nlines = \
+                "[ads-txt]\nmodules = [\"iabtl\"]\n\n[ads-txt.iabtl]\nlines = \
                  [\"{RECORD}\"]\n\n[[fetch]]\nmedia_type = \"text/plain\"\n{path_line}\
-                 middleware = [\"ads-txt.sellers\"]\n"
+                 middleware = [\"ads-txt.iabtl\"]\n"
             ));
 
             let Err(refused) = validate(&settings) else {
                 panic!("should refuse the module placed at {path:?}, where no file is made");
             };
             assert!(
-                format!("{refused:?}").contains("with path = `/ads.txt` names `ads-txt.sellers`"),
+                format!("{refused:?}").contains("with path = `/ads.txt` names `ads-txt.iabtl`"),
                 "should ask for the entry on `/ads.txt`: {refused:?}"
             );
             assert!(
@@ -466,7 +475,7 @@ mod tests {
                     .current_context()
                     .to_string();
                 assert!(
-                    message.contains("`lines` in [ads-txt.sellers], line 2")
+                    message.contains("`lines` in [ads-txt.iabtl], line 2")
                         && message.contains(reason),
                     "{call} should say {reason:?} of {line:?}, and said {message:?}"
                 );
@@ -575,4 +584,18 @@ mod tests {
         assert!(!sellers.handles_media_type("text/html"));
         assert_eq!(sellers.phases(), [MiddlewarePhase::Fetch]);
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/sellers.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
 }
diff --git a/crates/auction/prebid/src/lib.rs b/crates/auction/prebid/src/lib.rs
index 19f7b061c8..9b0a346ec4 100644
--- a/crates/auction/prebid/src/lib.rs
+++ b/crates/auction/prebid/src/lib.rs
@@ -61,6 +61,14 @@ pub(crate) const PREBID_INTEGRATION_ID: &str = "prebid";
 /// The name this module is selected by, in `[auction]`.
 pub const MODULE: &str = "auction.prebid";
 
+/// The page change the module supplies, as an entry names it.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+];
+
 /// The builder a deployment hands to an adapter. Prebid is selected in
 /// `[auction]`, registered from the auction plan and checked against it.
 #[must_use]
@@ -74,6 +82,7 @@ pub fn builder() -> trusted_server_core::integrations::IntegrationBuilder {
     .with_module_name(MODULE)
     .with_plan_registration(register_for_plan)
     .with_plan_validator(validate_against_plan)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 /// Prebid's registration needs the auction plan, so [`register_for_plan`]
@@ -3470,4 +3479,18 @@ server_url = "https://prebid.example"
             ),
         );
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
 }
diff --git a/crates/audience/permutive/src/lib.rs b/crates/audience/permutive/src/lib.rs
index b87ac9358f..12b1a46b6d 100644
--- a/crates/audience/permutive/src/lib.rs
+++ b/crates/audience/permutive/src/lib.rs
@@ -45,6 +45,14 @@ const PERMUTIVE_INTEGRATION_ID: &str = "permutive";
 /// The name this module is selected by, in `[audience]`.
 pub const MODULE: &str = "audience.permutive";
 
+/// The page change the module supplies, as an entry names it.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+];
+
 /// The builder a deployment hands to an adapter, which the registry runs when
 /// a section selects [`MODULE`].
 #[must_use]
@@ -56,6 +64,7 @@ pub fn builder() -> trusted_server_core::integrations::IntegrationBuilder {
         validate,
     )
     .with_module_name(MODULE)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 /// Configuration for Permutive integration.
@@ -815,6 +824,20 @@ mod tests {
         );
     }
 
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
+
     #[test]
     fn permutive_proxy_does_not_forward_host_signal_headers() {
         // Every proxied route forwards the reader's custom `x-` headers, so
diff --git a/crates/bot-protection/datadome/src/lib.rs b/crates/bot-protection/datadome/src/lib.rs
index bba669c719..0e8f982e07 100644
--- a/crates/bot-protection/datadome/src/lib.rs
+++ b/crates/bot-protection/datadome/src/lib.rs
@@ -118,6 +118,18 @@ pub const MODULE: &str = "bot-protection.datadome";
 /// into each reader's copy of a page.
 pub const TAG_MIDDLEWARE: &str = "bot-protection.datadome.tag";
 
+/// The page changes the module supplies, as an entry names them.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        TAG_MIDDLEWARE,
+        trusted_server_core::middleware::MiddlewarePhase::Serve,
+    ),
+];
+
 /// The builder a deployment hands to an adapter, which the registry runs when
 /// a section selects [`MODULE`].
 #[must_use]
@@ -130,6 +142,7 @@ pub fn builder() -> trusted_server_core::integrations::IntegrationBuilder {
     )
     .with_module_name(MODULE)
     .with_secret_settings(SECRET_SETTINGS)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 /// The two settings that name a secret. The server-side key is in use when
@@ -2146,4 +2159,20 @@ mod tests {
             ),
         );
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            // The constant, because code scanning treats a value read from a
+            // builder that declares secret settings as a secret.
+            super::DATADOME_INTEGRATION_ID,
+        );
+    }
 }
diff --git a/crates/cmp/didomi/src/lib.rs b/crates/cmp/didomi/src/lib.rs
index c9dd6c1372..afe72d37bc 100644
--- a/crates/cmp/didomi/src/lib.rs
+++ b/crates/cmp/didomi/src/lib.rs
@@ -36,6 +36,14 @@ const DIDOMI_INTEGRATION_ID: &str = "didomi";
 /// The name this module is selected by, in `[cmp]`.
 pub const MODULE: &str = "cmp.didomi";
 
+/// The page change the module supplies, as an entry names it. It runs in either phase and is described in the one a generated configuration places it in.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+];
+
 /// The builder a deployment hands to an adapter, which the registry runs when
 /// a section selects [`MODULE`].
 #[must_use]
@@ -47,6 +55,7 @@ pub fn builder() -> trusted_server_core::integrations::IntegrationBuilder {
         validate,
     )
     .with_module_name(MODULE)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 const DIDOMI_DEFAULT_PREFIX: &str = "/integrations/didomi/consent";
 
@@ -1587,6 +1596,20 @@ mod tests {
         );
     }
 
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
+
     /// Named in `[[serve]]` in place of `[[fetch]]`, the page change passes
     /// the registry's check and gives a reader the recorded page, because a
     /// page with no other middleware gets it in the same place from either
diff --git a/crates/cmp/inmobi/src/lib.rs b/crates/cmp/inmobi/src/lib.rs
index 1394bb3114..abdbb59fad 100644
--- a/crates/cmp/inmobi/src/lib.rs
+++ b/crates/cmp/inmobi/src/lib.rs
@@ -32,6 +32,14 @@ const INMOBI_INTEGRATION_ID: &str = "inmobi";
 /// by, from this crate's folder. Its settings are the table `[cmp.inmobi]`.
 pub const MODULE: &str = "cmp.inmobi";
 
+/// The page change the module supplies, as an entry names it. It runs in either phase and is described in the one a generated configuration places it in.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+];
+
 /// Hosts a Choice tag may be served from.
 const ALLOWED_HOSTS: [&str; 2] = ["cmp.inmobi.com", "cdn.inmobi.com"];
 
@@ -369,6 +377,7 @@ pub fn builder() -> IntegrationBuilder {
         validate,
     )
     .with_module_name(MODULE)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 /// The Choice consent prompt's tag, being the TCF stub, the GPP stub and the
@@ -1326,6 +1335,20 @@ mod tests {
         );
     }
 
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
+
     /// Named in `[[serve]]` in place of `[[fetch]]`, the prompt passes the
     /// registry's check and gives a reader the recorded page, because a page
     /// with no other middleware gets it in the same place from either phase.
diff --git a/crates/cmp/sourcepoint/src/lib.rs b/crates/cmp/sourcepoint/src/lib.rs
index 4773da65f4..9230a35863 100644
--- a/crates/cmp/sourcepoint/src/lib.rs
+++ b/crates/cmp/sourcepoint/src/lib.rs
@@ -63,6 +63,14 @@ const SOURCEPOINT_INTEGRATION_ID: &str = "sourcepoint";
 /// The name this module is selected by, in `[cmp]`.
 pub const MODULE: &str = "cmp.sourcepoint";
 
+/// The page change the module supplies, as an entry names it. It runs in either phase and is described in the one a generated configuration places it in.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+];
+
 /// The builder a deployment hands to an adapter, which the registry runs when
 /// a section selects [`MODULE`].
 #[must_use]
@@ -74,6 +82,7 @@ pub fn builder() -> trusted_server_core::integrations::IntegrationBuilder {
         validate,
     )
     .with_module_name(MODULE)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 const SOURCEPOINT_CDN_HOST: &str = "cdn.privacy-mgmt.com";
 const SOURCEPOINT_CDN_PREFIX: &str = "/integrations/sourcepoint/cdn";
@@ -3170,6 +3179,20 @@ mod tests {
         );
     }
 
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
+
     /// Named in `[[serve]]` in place of `[[fetch]]`, the page change passes
     /// the registry's check and gives a reader the recorded page, because a
     /// page with no other middleware gets it in the same place from either
diff --git a/crates/framework/nextjs/src/lib.rs b/crates/framework/nextjs/src/lib.rs
index b9d07ecdcc..5ed72c912b 100644
--- a/crates/framework/nextjs/src/lib.rs
+++ b/crates/framework/nextjs/src/lib.rs
@@ -27,6 +27,19 @@ const NEXTJS_INTEGRATION_ID: &str = "nextjs";
 /// The name this module is selected by, in `[framework]`.
 pub const MODULE: &str = "framework.nextjs";
 
+/// The page change the module supplies, as an entry names it.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+    trusted_server_core::integrations::SuppliedMiddleware::on(
+        flight::FLIGHT_MIDDLEWARE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+        flight::FLIGHT_MEDIA_TYPE,
+    ),
+];
+
 /// The builder a deployment hands to an adapter, which the registry runs when
 /// a section selects [`MODULE`].
 #[must_use]
@@ -38,6 +51,7 @@ pub fn builder() -> trusted_server_core::integrations::IntegrationBuilder {
         validate,
     )
     .with_module_name(MODULE)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 mod flight;
@@ -1178,4 +1192,18 @@ mod tests {
             ),
         );
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
 }
diff --git a/crates/headers/geo/src/lib.rs b/crates/headers/geo/src/lib.rs
index 6c0c912682..844394ed5d 100644
--- a/crates/headers/geo/src/lib.rs
+++ b/crates/headers/geo/src/lib.rs
@@ -15,7 +15,9 @@ use validator::{Validate, ValidationErrors};
 
 use trusted_server_core::error::TrustedServerError;
 use trusted_server_core::geo::GeoInfo;
-use trusted_server_core::integrations::{IntegrationBuilder, IntegrationRegistration};
+use trusted_server_core::integrations::{
+    IntegrationBuilder, IntegrationRegistration, SuppliedMiddleware,
+};
 use trusted_server_core::middleware::{
     Middleware, MiddlewareAction, MiddlewareContext, MiddlewarePhase, Preparation, ResponseHeader,
     is_dispatched_media_type,
@@ -109,11 +111,16 @@ pub fn register(
     ))
 }
 
+/// The page change the module supplies, as an entry names it.
+const SUPPLIED_MIDDLEWARE: &[SuppliedMiddleware] =
+    &[SuppliedMiddleware::on_html(MODULE, MiddlewarePhase::Serve)];
+
 /// The builder a deployment installs to offer this module.
 #[must_use]
 pub fn builder() -> IntegrationBuilder {
     IntegrationBuilder::new(INTEGRATION_ID, env!("CARGO_PKG_NAME"), register, validate)
         .with_module_name(MODULE)
+        .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 /// The middleware, which writes the location the request resolved.
@@ -609,4 +616,15 @@ mod tests {
         );
         assert_eq!(calls, 1, "should still resolve the request's location once");
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &page_settings(PLACED),
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
 }
diff --git a/crates/identity/lockr/src/lib.rs b/crates/identity/lockr/src/lib.rs
index b04265eb22..22fcf1b0ab 100644
--- a/crates/identity/lockr/src/lib.rs
+++ b/crates/identity/lockr/src/lib.rs
@@ -49,6 +49,14 @@ const LOCKR_INTEGRATION_ID: &str = "lockr";
 /// The name this module is selected by, in `[identity]`.
 pub const MODULE: &str = "identity.lockr";
 
+/// The page change the module supplies, as an entry names it.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+];
+
 /// The builder a deployment hands to an adapter, which the registry runs when
 /// a section selects [`MODULE`].
 #[must_use]
@@ -60,6 +68,7 @@ pub fn builder() -> trusted_server_core::integrations::IntegrationBuilder {
         validate,
     )
     .with_module_name(MODULE)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 /// Configuration for Lockr integration.
@@ -857,4 +866,18 @@ mod tests {
             ),
         );
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
 }
diff --git a/crates/tag/google-tag-manager/src/lib.rs b/crates/tag/google-tag-manager/src/lib.rs
index 31e316f4a7..6c39d5bf14 100644
--- a/crates/tag/google-tag-manager/src/lib.rs
+++ b/crates/tag/google-tag-manager/src/lib.rs
@@ -60,6 +60,14 @@ static FIRST_PARTY_PREFIX: LazyLock<String> =
 /// The name this module is selected by, in `[tag]`.
 pub const MODULE: &str = "tag.google-tag-manager";
 
+/// The page change the module supplies, as an entry names it.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+];
+
 /// The builder a deployment hands to an adapter, which the registry runs when
 /// a section selects [`MODULE`].
 #[must_use]
@@ -71,6 +79,7 @@ pub fn builder() -> trusted_server_core::integrations::IntegrationBuilder {
         validate,
     )
     .with_module_name(MODULE)
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 const DEFAULT_UPSTREAM: &str = "https://www.googletagmanager.com";
 /// Host serving the GA beacon endpoints the `/collect` paths are pinned to.
@@ -4092,4 +4101,18 @@ j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
             ),
         );
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
 }
diff --git a/crates/tag/google-tag/src/lib.rs b/crates/tag/google-tag/src/lib.rs
index 8f5aafc60b..370a9bf9e3 100644
--- a/crates/tag/google-tag/src/lib.rs
+++ b/crates/tag/google-tag/src/lib.rs
@@ -57,6 +57,14 @@ const GOOGLE_TAG_INTEGRATION_ID: &str = "google_tag";
 /// The name this module is selected by, in `[tag]`.
 pub const MODULE: &str = "tag.google-tag";
 
+/// The page change the module supplies, as an entry names it.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Serve,
+    ),
+];
+
 /// The name a module's builder gives as its source, this crate's package.
 const SOURCE: &str = "trusted-server-tag-google-tag";
 
@@ -65,6 +73,7 @@ const SOURCE: &str = "trusted-server-tag-google-tag";
 pub fn builder() -> IntegrationBuilder {
     IntegrationBuilder::new(GOOGLE_TAG_INTEGRATION_ID, SOURCE, register, validate)
         .with_module_name(MODULE)
+        .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 /// Google's own address for the tag loader.
@@ -1942,4 +1951,18 @@ mod tests {
             }
         }
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
 }
diff --git a/crates/testing/seam-probe/.gitattributes b/crates/testing/iabtl/.gitattributes
similarity index 100%
rename from crates/testing/seam-probe/.gitattributes
rename to crates/testing/iabtl/.gitattributes
diff --git a/crates/testing/seam-probe/Cargo.toml b/crates/testing/iabtl/Cargo.toml
similarity index 96%
rename from crates/testing/seam-probe/Cargo.toml
rename to crates/testing/iabtl/Cargo.toml
index a2252e2586..6aaf53042d 100644
--- a/crates/testing/seam-probe/Cargo.toml
+++ b/crates/testing/iabtl/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "trusted-server-integration-seam-probe"
+name = "trusted-server-testing-iabtl"
 description = "Test fixture integration that exercises the Trusted Server integration seam from outside the core crate. Never ship in a deployment."
 authors = { workspace = true }
 edition = { workspace = true }
diff --git a/crates/testing/seam-probe/js/probe.js b/crates/testing/iabtl/js/probe.js
similarity index 100%
rename from crates/testing/seam-probe/js/probe.js
rename to crates/testing/iabtl/js/probe.js
diff --git a/crates/testing/seam-probe/src/lib.rs b/crates/testing/iabtl/src/lib.rs
similarity index 95%
rename from crates/testing/seam-probe/src/lib.rs
rename to crates/testing/iabtl/src/lib.rs
index fc7afef035..25825bd781 100644
--- a/crates/testing/seam-probe/src/lib.rs
+++ b/crates/testing/iabtl/src/lib.rs
@@ -44,7 +44,7 @@ use trusted_server_core::error::TrustedServerError;
 use trusted_server_core::evidence::RequestInfo;
 use trusted_server_core::integrations::{
     AttributeRewriteAction, CarriedJsModule, IntegrationBuilder, IntegrationEndpoint,
-    IntegrationProxy, IntegrationRegistration, ScriptRewriteAction,
+    IntegrationProxy, IntegrationRegistration, ScriptRewriteAction, SuppliedMiddleware,
 };
 use trusted_server_core::middleware::{
     AttributeRewrite, Middleware, MiddlewareAction, MiddlewareContext, MiddlewarePhase, TextHandler,
@@ -63,9 +63,9 @@ use validator::Validate;
 pub const SEAM_PROBE_ID: &str = "seam_probe";
 
 /// The name this module is selected by, its crate folder below `crates/`, so
-/// `[testing] modules = ["seam-probe"]` selects it. Its geo, Edge Cookie and
+/// `[testing] modules = ["iabtl"]` selects it. Its geo, Edge Cookie and
 /// device modules carry the same name, so `[geo] module`, `[ec] module` and
-/// `[device] module` select each of them as `testing.seam-probe`, and so does
+/// `[device] module` select each of them as `testing.iabtl`, and so does
 /// `[robots-txt] modules` its robots.txt contributor.
 #[must_use]
 pub fn module_name() -> &'static str {
@@ -76,7 +76,7 @@ pub fn module_name() -> &'static str {
 pub const SEAM_PROBE_ROBOTS_AGENT: &str = "SeamProbeBot";
 
 /// Source label the registry uses in duplicate-id errors.
-pub const SEAM_PROBE_SOURCE: &str = "trusted-server-integration-seam-probe";
+pub const SEAM_PROBE_SOURCE: &str = "trusted-server-testing-iabtl";
 
 /// Path of the proxy route that reports what the seam delivered.
 ///
@@ -111,7 +111,7 @@ pub const PROBE_JS_SHA256: &str =
 /// can prove deploy validation reached a vendor's rules rather than stopping
 /// at the core ones.
 pub const SEAM_PROBE_COUNTRY_MESSAGE: &str =
-    "`[testing.seam-probe] country` must be exactly two letters";
+    "`[testing.iabtl] country` must be exactly two letters";
 
 /// Request header a caller sets to have the preparer, and the handler of
 /// [`SEAM_PROBE_OWN_PATH`], count that request.
@@ -326,7 +326,7 @@ pub struct SeamProbePrepared {
     pub runs: usize,
 }
 
-/// The probe's own configuration block, `[testing.seam-probe]`.
+/// The probe's own configuration block, `[testing.iabtl]`.
 #[derive(Debug, Deserialize, Validate)]
 #[serde(deny_unknown_fields)]
 pub struct SeamProbeConfig {
@@ -339,7 +339,7 @@ pub struct SeamProbeConfig {
     /// Whether the registration declares the probe's geo module.
     ///
     /// Set this to `false` to build a selected module that supplies no geo
-    /// module, which is what `[geo] module = "testing.seam-probe"` must
+    /// module, which is what `[geo] module = "testing.iabtl"` must
     /// reject at startup.
     #[serde(default = "default_declares_geo")]
     pub declares_geo: bool,
@@ -552,7 +552,7 @@ impl PlatformGeo for SeamProbeGeo {
 ///
 /// A static cannot call [`module_name`], so the literal is written out and
 /// `auction_implementations_are_named_as_the_module` keeps it honest.
-pub const SEAM_PROBE_ADSERVER_NAME: &str = "testing.seam-probe";
+pub const SEAM_PROBE_ADSERVER_NAME: &str = "testing.iabtl";
 
 /// The probe's demand implementation, registered on its builder.
 pub static SEAM_PROBE_DEMAND: DemandImplementation = DemandImplementation {
@@ -891,10 +891,19 @@ pub fn prepare_request(
 /// # Examples
 ///
 /// ```
-/// use trusted_server_integration_seam_probe::{builder, SEAM_PROBE_ID};
+/// use trusted_server_testing_iabtl::{builder, SEAM_PROBE_ID};
 ///
 /// assert_eq!(builder().id(), SEAM_PROBE_ID);
 /// ```
+/// The page changes the probe supplies, as an entry names them. Made once,
+/// because the names come from the crate's folder at run time.
+static SUPPLIED_MIDDLEWARE: LazyLock<[SuppliedMiddleware; 2]> = LazyLock::new(|| {
+    [
+        SuppliedMiddleware::on_html(module_name(), MiddlewarePhase::Fetch),
+        SuppliedMiddleware::on_html(reader_middleware_name(), MiddlewarePhase::Serve),
+    ]
+});
+
 #[must_use]
 pub fn builder() -> IntegrationBuilder {
     IntegrationBuilder::new(SEAM_PROBE_ID, SEAM_PROBE_SOURCE, register, validate)
@@ -903,16 +912,17 @@ pub fn builder() -> IntegrationBuilder {
         .with_demand(&SEAM_PROBE_DEMAND)
         .with_adserver(&SEAM_PROBE_ADSERVER)
         .with_cache_features(&[SEAM_PROBE_ANSWERS_CACHE])
+        .with_middleware(SUPPLIED_MIDDLEWARE.as_slice())
 }
 
 /// The cache the probe declares and loads its answers through, selected in
-/// `[cache.seam-probe-answers]`. The report route says whether the cache
+/// `[cache.iabtl-answers]`. The report route says whether the cache
 /// that table selected keeps values.
-pub const SEAM_PROBE_ANSWERS_CACHE: &str = "seam-probe-answers";
+pub const SEAM_PROBE_ANSWERS_CACHE: &str = "iabtl-answers";
 
 /// The id of the loading cache module the probe offers, selected in a
-/// `[cache.<name>]` table as `module = "seam-probe"`.
-pub const SEAM_PROBE_LOADING_CACHE_ID: &str = "loading-cache.seam-probe";
+/// `[cache.<name>]` table as `module = "iabtl"`.
+pub const SEAM_PROBE_LOADING_CACHE_ID: &str = "loading-cache.iabtl";
 
 /// A loading cache that keeps every value in this process's memory for as
 /// long as the process runs, enough to prove from outside core that a table
@@ -964,9 +974,9 @@ pub fn loading_cache_builder() -> IntegrationBuilder {
         .with_loading_cache(memory_loading_cache)
 }
 
-/// The vendor's name, which names the table `[shared.seam-probe]` that runs
+/// The vendor's name, which names the table `[shared.iabtl]` that runs
 /// [`shared_builder`].
-pub const SEAM_PROBE_SHARED_VENDOR: &str = "seam-probe";
+pub const SEAM_PROBE_SHARED_VENDOR: &str = "iabtl";
 
 /// The id of the builder the shared table runs.
 pub const SEAM_PROBE_SHARED_ID: &str = "seam_probe_shared";
@@ -977,7 +987,7 @@ pub const SEAM_PROBE_SHARED_PATH: &str = "/integrations/seam_probe_shared/marker
 /// The shared route's suffix under the builder's proxy prefix.
 const SHARED_ROUTE_SUFFIX: &str = "/marker";
 
-/// What `[shared.seam-probe]` carries.
+/// What `[shared.iabtl]` carries.
 #[derive(Debug, Clone, Deserialize, Validate)]
 #[serde(deny_unknown_fields)]
 pub struct SeamProbeShared {
@@ -1033,7 +1043,7 @@ impl IntegrationProxy for SharedMarkerRoute {
     }
 }
 
-/// Registers the shared route when `[shared.seam-probe]` is present.
+/// Registers the shared route when `[shared.iabtl]` is present.
 ///
 /// # Errors
 ///
@@ -1065,7 +1075,7 @@ pub fn validate_shared(settings: &Settings) -> Result<bool, Report<TrustedServer
         .is_some())
 }
 
-/// The builder `[shared.seam-probe]` runs, which proves a vendor's shared
+/// The builder `[shared.iabtl]` runs, which proves a vendor's shared
 /// table from outside core.
 #[must_use]
 pub fn shared_builder() -> IntegrationBuilder {
@@ -1184,7 +1194,7 @@ mod tests {
             .build()
     }
 
-    /// Settings carrying a `[testing.seam-probe]` block with `body`
+    /// Settings carrying a `[testing.iabtl]` block with `body`
     /// appended to it.
     fn settings_with_probe(body: &str) -> Settings {
         Settings::from_toml(&format!(
@@ -1207,9 +1217,9 @@ mod tests {
                 assume_single_jurisdiction = true
 
                 [testing]
-                modules = ["seam-probe"]
+                modules = ["iabtl"]
 
-                [testing.seam-probe]
+                [testing.iabtl]
                 {body}
             "#
         ))
@@ -1248,7 +1258,7 @@ mod tests {
 
                 [[fetch]]
                 media_type = "text/html"
-                middleware = ["testing.seam-probe"]
+                middleware = ["testing.iabtl"]
             "#,
         );
 
@@ -1303,11 +1313,11 @@ mod tests {
 
                 [[fetch]]
                 media_type = "text/html"
-                middleware = ["testing.seam-probe"]
+                middleware = ["testing.iabtl"]
 
                 [[serve]]
                 media_type = "text/html"
-                middleware = ["testing.seam-probe.reader"]
+                middleware = ["testing.iabtl.reader"]
             "#,
         );
 
@@ -1329,7 +1339,7 @@ mod tests {
         );
         assert_eq!(
             reader_middleware_name(),
-            "testing.seam-probe.reader",
+            "testing.iabtl.reader",
             "should name the serve middleware after the module"
         );
     }
@@ -1540,4 +1550,16 @@ mod tests {
             "should count both runs"
         );
     }
+
+    /// The builder describes the two middleware the registration supplies,
+    /// so a tool that writes a configuration places what the probe registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_probe_registers() {
+        let settings = settings_with_probe("country = \"NZ\"");
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[builder()],
+            SEAM_PROBE_ID,
+        );
+    }
 }
diff --git a/crates/testing/testlight/src/lib.rs b/crates/testing/testlight/src/lib.rs
index 4c8f75f85c..e17e96748b 100644
--- a/crates/testing/testlight/src/lib.rs
+++ b/crates/testing/testlight/src/lib.rs
@@ -42,6 +42,14 @@ const TESTLIGHT_INTEGRATION_ID: &str = "testlight";
 /// The name this module is selected by, in `[auction]`.
 pub const MODULE: &str = "testing.testlight";
 
+/// The page change the module supplies, as an entry names it.
+const SUPPLIED_MIDDLEWARE: &[trusted_server_core::integrations::SuppliedMiddleware] = &[
+    trusted_server_core::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        trusted_server_core::middleware::MiddlewarePhase::Fetch,
+    ),
+];
+
 /// The builder a deployment hands to an adapter, which the registry runs when
 /// a section selects [`MODULE`].
 #[must_use]
@@ -54,6 +62,7 @@ pub fn builder() -> trusted_server_core::integrations::IntegrationBuilder {
     )
     .with_module_name(MODULE)
     .selected_in("auction")
+    .with_middleware(SUPPLIED_MIDDLEWARE)
 }
 
 #[derive(Debug, Deserialize, Validate)]
@@ -702,4 +711,18 @@ mod tests {
             ),
         );
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = trusted_server_core::html_processor::test_support::page_settings(
+            include_str!("fixtures/page-change.settings.toml"),
+        );
+        trusted_server_core::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[super::builder()],
+            super::builder().id(),
+        );
+    }
 }
diff --git a/crates/trusted-server-adapter-axum/Cargo.toml b/crates/trusted-server-adapter-axum/Cargo.toml
index a950690d05..ab081dd128 100644
--- a/crates/trusted-server-adapter-axum/Cargo.toml
+++ b/crates/trusted-server-adapter-axum/Cargo.toml
@@ -28,13 +28,31 @@ log = { workspace = true }
 reqwest = { workspace = true }
 simple_logger = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros", "sync", "time"] }
+trusted-server-ad-server-iabtl = { workspace = true }
+trusted-server-ad-tag-google = { workspace = true }
+trusted-server-ads-txt-iabtl = { workspace = true }
+trusted-server-auction-aps = { workspace = true }
+trusted-server-auction-prebid = { workspace = true }
+trusted-server-auction-prebid-server = { workspace = true }
+trusted-server-auction-protocol-openrtb = { workspace = true }
+trusted-server-audience-permutive = { workspace = true }
+trusted-server-bot-protection-datadome = { workspace = true }
+trusted-server-cmp-didomi = { workspace = true }
+trusted-server-cmp-inmobi = { workspace = true }
+trusted-server-cmp-osano = { workspace = true }
+trusted-server-cmp-sourcepoint = { workspace = true }
 trusted-server-core = { workspace = true }
-trusted-server-modules = { workspace = true }
+trusted-server-framework-nextjs = { workspace = true }
+trusted-server-headers-geo = { workspace = true }
+trusted-server-identity-lockr = { workspace = true }
 trusted-server-permission-signal-gpc = { workspace = true }
 trusted-server-permission-signal-gpp = { workspace = true }
 trusted-server-permission-signal-mtm = { workspace = true }
 trusted-server-permission-signal-tcf = { workspace = true }
 trusted-server-permission-signal-us-privacy = { workspace = true }
+trusted-server-tag-google-tag = { workspace = true }
+trusted-server-tag-google-tag-manager = { workspace = true }
+trusted-server-testing-testlight = { workspace = true }
 
 [dev-dependencies]
 trusted-server-core = { workspace = true, features = ["test-utils"] }
@@ -47,4 +65,4 @@ tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 tower = { workspace = true, features = ["util"] }
 # Test fixture only. It proves the integration seam from outside core and must
 # never reach a production build, so it stays a dev-dependency.
-trusted-server-integration-seam-probe = { path = "../testing/seam-probe" }
+trusted-server-testing-iabtl = { path = "../testing/iabtl" }
diff --git a/crates/trusted-server-adapter-axum/src/app.rs b/crates/trusted-server-adapter-axum/src/app.rs
index ee49bcfe72..9fca1852c6 100644
--- a/crates/trusted-server-adapter-axum/src/app.rs
+++ b/crates/trusted-server-adapter-axum/src/app.rs
@@ -107,6 +107,53 @@ fn shipped_signal_modules()
     ]
 }
 
+/// The module builders this adapter links, in the order their request hooks
+/// run. Offering a module does not run it, because the registry builds a
+/// module only when a section of the settings selects it.
+///
+/// A deployment that wants a different set links a different set, and one
+/// that adds a module of its own hands its builder to [`build_state_with_registrations`], which
+/// runs it after these. None of these offers a loading cache, so a
+/// deployment that wants copies kept hands one the same way.
+#[must_use]
+pub fn shipped_module_builders() -> Vec<IntegrationBuilder> {
+    vec![
+        // Prebid registers from the auction plan, and what it registers runs
+        // ahead of the modules below.
+        trusted_server_auction_prebid::builder(),
+        trusted_server_testing_testlight::builder(),
+        trusted_server_framework_nextjs::builder(),
+        trusted_server_audience_permutive::builder(),
+        trusted_server_identity_lockr::builder(),
+        trusted_server_cmp_didomi::builder(),
+        trusted_server_cmp_inmobi::builder(),
+        trusted_server_cmp_sourcepoint::builder(),
+        trusted_server_cmp_osano::builder(),
+        trusted_server_tag_google_tag::builder(),
+        trusted_server_tag_google_tag_manager::builder(),
+        trusted_server_bot_protection_datadome::builder(),
+        trusted_server_ad_tag_google::builder(),
+        trusted_server_ad_tag_google::diagnostics::builder(),
+        trusted_server_ads_txt_iabtl::builder(),
+        trusted_server_headers_geo::builder(),
+        // Implementations `[demand]` and `[ad-server]` can name, which no
+        // section selects.
+        trusted_server_auction_protocol_openrtb::builder(),
+        trusted_server_auction_prebid_server::builder(),
+        trusted_server_auction_aps::builder(),
+        trusted_server_ad_server_iabtl::builder(),
+    ]
+}
+
+/// The builders this adapter links followed by `extra`, a deployment's own,
+/// which is the order their hooks run in.
+#[must_use]
+pub fn module_builders_with(extra: &[IntegrationBuilder]) -> Vec<IntegrationBuilder> {
+    let mut all = shipped_module_builders();
+    all.extend_from_slice(extra);
+    all
+}
+
 /// Build the application state, loading settings and constructing all per-application components.
 ///
 /// # Errors
@@ -125,7 +172,7 @@ fn build_state() -> Result<Arc<AppState>, Report<TrustedServerError>> {
         &config_key,
         &trusted_server_core::settings_data::default_secret_store_name(),
         PolicyOrigin::Source(&AxumPolicyFolder::from_env()),
-        &trusted_server_modules::builders(),
+        &shipped_module_builders(),
     )?;
     build_state_with_settings(settings)
 }
@@ -144,7 +191,7 @@ fn build_state_with_settings(
 }
 
 /// Build the application state from explicit settings, composing the modules
-/// a stock build ships with the externally supplied builders in
+/// this adapter links with the externally supplied builders in
 /// `integrations`.
 ///
 /// A deployment that ships a vendor crate calls this to add that crate's
@@ -180,9 +227,9 @@ fn build_state_with_registrations_and_services(
     integrations: &[IntegrationBuilder],
     services: Option<RuntimeServices>,
 ) -> Result<Arc<AppState>, Report<TrustedServerError>> {
-    // The modules a stock build ships come first and the deployment's own
+    // The modules this adapter links come first and the deployment's own
     // follow, which is the order their hooks run in.
-    let integrations = trusted_server_modules::builders_with(integrations);
+    let integrations = module_builders_with(integrations);
     let integrations = integrations.as_slice();
 
     // The plan is compiled with the integrations this adapter was given, so an
@@ -1080,6 +1127,90 @@ mod tests {
         );
     }
 
+    /// The modules this adapter links are offered in the order their hooks
+    /// run. A module is named by what its section selects, and an
+    /// implementation by what `[demand]` or `[ad-server]` names.
+    #[test]
+    fn the_linked_modules_are_offered_in_hook_order() {
+        let names: Vec<&str> = shipped_module_builders()
+            .iter()
+            .map(|builder| {
+                builder
+                    .module_name()
+                    .or_else(|| builder.demand().map(|demand| demand.id))
+                    .or_else(|| builder.adserver().map(|adserver| adserver.id))
+                    .unwrap_or_else(|| builder.id())
+            })
+            .collect();
+
+        assert_eq!(
+            names,
+            [
+                "auction.prebid",
+                "testing.testlight",
+                "framework.nextjs",
+                "audience.permutive",
+                "identity.lockr",
+                "cmp.didomi",
+                "cmp.inmobi",
+                "cmp.sourcepoint",
+                "cmp.osano",
+                "tag.google-tag",
+                "tag.google-tag-manager",
+                "bot-protection.datadome",
+                "ad-tag.google",
+                "ad-tag.google.diagnostics",
+                "ads-txt.iabtl",
+                "headers.geo",
+                "auction-protocol.openrtb",
+                "auction.prebid-server",
+                "auction.aps",
+                "ad-server.iabtl",
+            ],
+            "should offer the linked modules in the order their hooks run"
+        );
+    }
+
+    /// This adapter links no loading cache module, so every feature loads
+    /// through `NoLoadingCache`, which keeps no copy, and a deployment that
+    /// wants copies kept hands a loading cache module's builder to it.
+    #[test]
+    fn the_stock_build_links_no_loading_cache() {
+        let offering: Vec<&str> = shipped_module_builders()
+            .iter()
+            .filter(|builder| builder.loading_cache().is_some())
+            .map(IntegrationBuilder::id)
+            .collect();
+
+        assert!(
+            offering.is_empty(),
+            "a stock build should link no loading cache, and links {offering:?}"
+        );
+    }
+
+    /// A deployment's builders follow the ones this adapter links.
+    #[test]
+    fn a_deployment_s_builders_follow_the_linked_ones() {
+        let linked = shipped_module_builders().len();
+        let extra = [IntegrationBuilder::implementations(
+            "deployment_fixture",
+            "deployment-crate",
+        )];
+
+        let all = module_builders_with(&extra);
+
+        assert_eq!(
+            all.len(),
+            linked + 1,
+            "should keep every linked builder and add the deployment's"
+        );
+        assert_eq!(
+            all.last().map(IntegrationBuilder::source),
+            Some("deployment-crate"),
+            "should put the deployment's builder last"
+        );
+    }
+
     mod startup_policy {
         use std::path::Path;
 
diff --git a/crates/trusted-server-adapter-axum/tests/routes.rs b/crates/trusted-server-adapter-axum/tests/routes.rs
index cd340decaf..b567e25841 100644
--- a/crates/trusted-server-adapter-axum/tests/routes.rs
+++ b/crates/trusted-server-adapter-axum/tests/routes.rs
@@ -900,15 +900,15 @@ async fn the_sellers_module_makes_an_ads_txt_the_origin_does_not_have() {
 
     const SELLERS: &str = r#"
         [ads-txt]
-        modules = ["sellers"]
+        modules = ["iabtl"]
 
-        [ads-txt.sellers]
+        [ads-txt.iabtl]
         lines = ["ssp.example, 12345, DIRECT, f08c47fec0942fa0"]
 
         [[fetch]]
         media_type = "text/plain"
         path = "/ads.txt"
-        middleware = ["ads-txt.sellers"]
+        middleware = ["ads-txt.iabtl"]
     "#;
 
     let origin = Arc::new(StubHttpClient::new());
diff --git a/crates/trusted-server-adapter-axum/tests/seam_probe.rs b/crates/trusted-server-adapter-axum/tests/seam_probe.rs
index 2e06add720..bf8ea14fc0 100644
--- a/crates/trusted-server-adapter-axum/tests/seam_probe.rs
+++ b/crates/trusted-server-adapter-axum/tests/seam_probe.rs
@@ -2,7 +2,7 @@
 //! `trusted-server-core`.
 //!
 //! Every capability the seam exposes is registered here by
-//! `trusted-server-integration-seam-probe`, a fixture crate core knows nothing
+//! `trusted-server-testing-iabtl`, a fixture crate core knows nothing
 //! about, and asserted through the Axum adapter's real router. Each test
 //! turns on an observable outcome (the bytes served, the JSON a route
 //! returns, the error a startup or deploy check produces) rather than on a
@@ -32,7 +32,7 @@ use trusted_server_core::platform::{
 use trusted_server_core::settings::Settings;
 use trusted_server_core::tsjs::tsjs_script_src;
 use trusted_server_core::tsjs_bundle::{JsModulePart, compile_time_parts};
-use trusted_server_integration_seam_probe as seam_probe;
+use trusted_server_testing_iabtl as seam_probe;
 
 /// Largest response body these tests read, ample for the served script.
 const MAX_BODY_BYTES: usize = 4 * 1024 * 1024;
@@ -85,9 +85,9 @@ assume_single_jurisdiction = true
 /// assertions expect.
 const PROBE_BLOCK: &str = r#"
             [testing]
-            modules = ["seam-probe"]
+            modules = ["iabtl"]
 
-            [testing.seam-probe]
+            [testing.iabtl]
             country = "ZZ"
 "#;
 
@@ -230,7 +230,7 @@ async fn proxy_route_reports_the_modules_geo_and_that_the_preparer_ran() {
     let settings = settings_with(&format!(
         r#"
             [geo]
-            module = "testing.seam-probe"
+            module = "testing.iabtl"
             {PROBE_BLOCK}
         "#
     ));
@@ -263,14 +263,14 @@ async fn proxy_route_reports_the_modules_geo_and_that_the_preparer_ran() {
     );
 }
 
-/// `[shared.seam-probe]` runs the builder the probe shares, whose route
+/// `[shared.iabtl]` runs the builder the probe shares, whose route
 /// answers the table's marker. Without the table the builder is not built,
 /// and the table with no builder reading it is refused at startup.
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn a_vendors_shared_table_runs_its_builder() {
     let mut with = service_with(
         settings_with(&format!(
-            "[shared.seam-probe]\nmarker = \"from the shared table\"\n{PROBE_BLOCK}"
+            "[shared.iabtl]\nmarker = \"from the shared table\"\n{PROBE_BLOCK}"
         )),
         &[seam_probe::builder(), seam_probe::shared_builder()],
     );
@@ -294,13 +294,13 @@ async fn a_vendors_shared_table_runs_its_builder() {
     );
 
     let refused = TrustedServerApp::routes_with_registrations(
-        settings_with("[shared.seam-probe]\nmarker = \"x\"\n"),
+        settings_with("[shared.iabtl]\nmarker = \"x\"\n"),
         &[seam_probe::builder()],
     )
     .err()
     .expect("nothing reads the table");
     assert!(
-        format!("{refused:?}").contains("[shared.seam-probe] is read by no module"),
+        format!("{refused:?}").contains("[shared.iabtl] is read by no module"),
         "{refused:?}"
     );
 }
@@ -359,7 +359,7 @@ fn robots_txt_selection_naming_a_module_that_is_not_running_fails_at_startup() {
     let settings = settings_with(
         r#"
             [robots-txt]
-            modules = ["testing.seam-probe"]
+            modules = ["testing.iabtl"]
 
             [[fetch]]
             media_type = "text/plain"
@@ -374,7 +374,7 @@ fn robots_txt_selection_naming_a_module_that_is_not_running_fails_at_startup() {
     let message = format!("{error:?}");
 
     assert!(
-        message.contains("`[robots-txt] modules` names `testing.seam-probe`"),
+        message.contains("`[robots-txt] modules` names `testing.iabtl`"),
         "should name the selection: {message}"
     );
     assert!(
@@ -529,9 +529,9 @@ fn deploy_validation_rejects_a_violation_of_the_modules_own_rule() {
     let settings = settings_with(
         r#"
             [testing]
-            modules = ["seam-probe"]
+            modules = ["iabtl"]
 
-            [testing.seam-probe]
+            [testing.iabtl]
             country = "ZZZ"
         "#,
     );
@@ -582,7 +582,7 @@ fn second_loading_cache_builder() -> IntegrationBuilder {
         .with_loading_cache(memory_loading_cache)
 }
 
-/// `[cache.seam-probe-answers]` selects the loading cache the probe's answers
+/// `[cache.iabtl-answers]` selects the loading cache the probe's answers
 /// are held in, the way `[cache.robots-txt]` selects core's. Left out, the
 /// cache takes the one loading cache module the build links, and keeps
 /// nothing when the build links none or several. A stock build links none,
@@ -592,8 +592,8 @@ fn second_loading_cache_builder() -> IntegrationBuilder {
 async fn a_cache_the_probe_declares_is_selected_in_its_own_table() {
     let named = settings_with(&format!(
         r#"
-            [cache.seam-probe-answers]
-            module = "seam-probe"
+            [cache.iabtl-answers]
+            module = "iabtl"
             {PROBE_BLOCK}
         "#
     ));
@@ -637,8 +637,8 @@ async fn a_cache_the_probe_declares_is_selected_in_its_own_table() {
 async fn a_cache_table_no_module_declares_is_refused_by_the_deploy_check_and_at_startup() {
     let settings = settings_with(&format!(
         r#"
-            [cache.seam-probe-answres]
-            module = "seam-probe"
+            [cache.iabtl-answres]
+            module = "iabtl"
             {PROBE_BLOCK}
         "#
     ));
@@ -654,11 +654,11 @@ async fn a_cache_table_no_module_declares_is_refused_by_the_deploy_check_and_at_
     // runner asks for one, and the two are raised on different stacks.
     let message = format!("{deploy}");
     assert!(
-        message.contains("[cache.seam-probe-answres]"),
+        message.contains("[cache.iabtl-answres]"),
         "should name the table: {message}"
     );
     assert!(
-        message.contains("robots-txt, seam-probe-answers"),
+        message.contains("robots-txt, iabtl-answers"),
         "should list the caches this build declares: {message}"
     );
     assert_eq!(
@@ -679,12 +679,12 @@ fn geo_selector_naming_a_module_without_a_geo_module_fails_at_startup() {
     let settings = settings_with(
         r#"
             [geo]
-            module = "testing.seam-probe"
+            module = "testing.iabtl"
 
             [testing]
-            modules = ["seam-probe"]
+            modules = ["iabtl"]
 
-            [testing.seam-probe]
+            [testing.iabtl]
             country = "ZZ"
             declares_geo = false
         "#,
@@ -696,7 +696,7 @@ fn geo_selector_naming_a_module_without_a_geo_module_fails_at_startup() {
 
     let message = error.to_string();
     assert!(
-        message.contains("`[geo] module` names `testing.seam-probe`")
+        message.contains("`[geo] module` names `testing.iabtl`")
             && message.contains("is selected and supplies no geo module"),
         "should name the module and the missing capability: {message}"
     );
@@ -716,7 +716,7 @@ fn fetch_entry_naming_a_modules_middleware_starts_the_adapter() {
             [[fetch]]
             media_type = "text/html"
             path = "/news/"
-            middleware = ["testing.seam-probe"]
+            middleware = ["testing.iabtl"]
             "#
         ))
     };
@@ -778,7 +778,7 @@ fn serve_entry_starts_the_adapter_only_with_a_middleware_of_that_phase() {
 
     let message = error.to_string();
     assert!(
-        message.contains("[[serve]] entry 1 names `testing.seam-probe`")
+        message.contains("[[serve]] entry 1 names `testing.iabtl`")
             && message.contains("does not run in that phase. It runs in [[fetch]]"),
         "should say which phase the middleware runs in: {message}"
     );
@@ -792,7 +792,7 @@ fn fetch_entry_naming_the_middleware_of_an_unselected_module_fails_at_startup()
         r#"
             [[fetch]]
             media_type = "text/html"
-            middleware = ["testing.seam-probe"]
+            middleware = ["testing.iabtl"]
         "#,
     );
 
@@ -802,8 +802,8 @@ fn fetch_entry_naming_the_middleware_of_an_unselected_module_fails_at_startup()
 
     let message = error.to_string();
     assert!(
-        message.contains("[[fetch]] entry 1 names `testing.seam-probe`")
-            && message.contains("`testing.seam-probe` is a module no section selects"),
+        message.contains("[[fetch]] entry 1 names `testing.iabtl`")
+            && message.contains("`testing.iabtl` is a module no section selects"),
         "should name the entry and say why the middleware is not running: {message}"
     );
 }
@@ -865,7 +865,7 @@ const PROBE_DEMAND_BLOCK: &str = r#"
             modules = ["probe"]
 
             [demand.probe]
-            implementation = "testing.seam-probe"
+            implementation = "testing.iabtl"
             endpoint = "https://demand.example/openrtb2/auction"
 "#;
 
@@ -891,13 +891,13 @@ fn demand_source_a_module_supplies_is_known_only_with_its_builder() {
         .expect("should refuse a demand source no builder in the deployment supplies");
     let message = error.to_string();
     assert!(
-        message.contains("[demand] `probe` uses implementation `testing.seam-probe`"),
+        message.contains("[demand] `probe` uses implementation `testing.iabtl`"),
         "should name the demand source and the implementation nothing supplies: {message}"
     );
     let error = validate_settings_for_deploy_with(&settings_with(PROBE_DEMAND_BLOCK), &[])
         .expect_err("should refuse the probe's demand source without the probe's builder");
     assert!(
-        error.to_string().contains("testing.seam-probe"),
+        error.to_string().contains("testing.iabtl"),
         "should name the implementation nothing supplies: {error}"
     );
 }
@@ -909,7 +909,7 @@ const PROBE_ADSERVER_BLOCK: &str = r#"
             module = "probe"
 
             [ad-server.probe]
-            implementation = "testing.seam-probe"
+            implementation = "testing.iabtl"
 "#;
 
 /// The adapter compiles the auction plan with the builders it is given, so an
@@ -933,7 +933,7 @@ fn ad_server_a_module_supplies_starts_the_adapter_only_with_its_builder() {
             .expect("should refuse an ad server no builder in the deployment supplies");
     let message = error.to_string();
     assert!(
-        message.contains("[ad-server] `probe` uses implementation `testing.seam-probe`"),
+        message.contains("[ad-server] `probe` uses implementation `testing.iabtl`"),
         "should name the ad server and the implementation nothing supplies: {message}"
     );
 }
@@ -950,7 +950,7 @@ fn deploy_validation_accepts_a_modules_ad_server_only_with_its_builder() {
     let error = validate_settings_for_deploy_with(&settings, &[])
         .expect_err("should refuse the probe's ad server without the probe's builder");
     assert!(
-        error.to_string().contains("testing.seam-probe"),
+        error.to_string().contains("testing.iabtl"),
         "should name the implementation nothing supplies: {error}"
     );
 }
@@ -1005,7 +1005,7 @@ fn ec_selector_naming_a_module_resolves_the_edge_cookie_module_it_declares() {
     let settings = settings_selecting_module(
         r#"
             [ec]
-            module = "testing.seam-probe"
+            module = "testing.iabtl"
         "#,
     );
 
@@ -1013,7 +1013,7 @@ fn ec_selector_naming_a_module_resolves_the_edge_cookie_module_it_declares() {
 
     let module = registry
         .ec_module()
-        .expect("`[ec] module = \"testing.seam-probe\"` should resolve the module's module");
+        .expect("`[ec] module = \"testing.iabtl\"` should resolve the module's module");
 
     assert_eq!(
         module.id(),
@@ -1033,7 +1033,7 @@ fn ec_selector_naming_a_label_resolves_the_module_its_block_names() {
             module = "probe"
 
             [ec.probe]
-            implementation = "testing.seam-probe"
+            implementation = "testing.iabtl"
         "#,
     );
 
@@ -1066,7 +1066,7 @@ fn ec_selector_naming_a_module_starts_the_adapter() {
     let settings = settings_selecting_module(
         r#"
             [ec]
-            module = "testing.seam-probe"
+            module = "testing.iabtl"
         "#,
     );
 
@@ -1086,7 +1086,7 @@ fn device_selector_naming_a_module_resolves_the_device_module_it_declares() {
     let settings = settings_selecting_module(
         r#"
             [device]
-            module = "testing.seam-probe"
+            module = "testing.iabtl"
         "#,
     );
 
@@ -1094,7 +1094,7 @@ fn device_selector_naming_a_module_resolves_the_device_module_it_declares() {
 
     let module = registry
         .device_module()
-        .expect("`[device] module = \"testing.seam-probe\"` should resolve the module's module");
+        .expect("`[device] module = \"testing.iabtl\"` should resolve the module's module");
 
     assert_eq!(
         module.id(),
@@ -1110,7 +1110,7 @@ fn prefix_selector_naming_a_module_resolves_the_prefix_module_it_declares() {
     let settings = settings_selecting_module(
         r#"
             [prefix]
-            module = "testing.seam-probe"
+            module = "testing.iabtl"
         "#,
     );
 
@@ -1131,7 +1131,7 @@ async fn a_requests_services_carry_the_selected_modules_prefixes() {
     let settings = settings_with(&format!(
         r#"
             [prefix]
-            module = "testing.seam-probe"
+            module = "testing.iabtl"
             {PROBE_BLOCK}
         "#
     ));
@@ -1162,13 +1162,13 @@ async fn the_resolved_device_module_answers_a_confidence_and_the_devices_attribu
     let settings = settings_selecting_module(
         r#"
             [device]
-            module = "testing.seam-probe"
+            module = "testing.iabtl"
         "#,
     );
     let registry = registry_with_probe(&settings);
     let module = registry
         .device_module()
-        .expect("`[device] module = \"testing.seam-probe\"` should resolve the module's module");
+        .expect("`[device] module = \"testing.iabtl\"` should resolve the module's module");
     let request = ModuleRequest::new(
         &axum::http::Method::GET,
         "www.publisher.example",
@@ -1216,7 +1216,7 @@ async fn ec_module_generates_an_identifier_with_the_modules_prefix() {
     let settings = settings_selecting_module(
         r#"
             [ec]
-            module = "testing.seam-probe"
+            module = "testing.iabtl"
         "#,
     );
 
@@ -1224,7 +1224,7 @@ async fn ec_module_generates_an_identifier_with_the_modules_prefix() {
 
     let module = registry
         .ec_module()
-        .expect("`[ec] module = \"testing.seam-probe\"` should resolve the module's module");
+        .expect("`[ec] module = \"testing.iabtl\"` should resolve the module's module");
 
     let request_info = OwnedRequestInfo::new("192.0.2.1".to_owned(), HeaderMap::new());
     let services = stub_services();
@@ -1466,9 +1466,9 @@ mod module_endpoints {
         let settings = settings_with(
             r#"
             [testing]
-            modules = ["seam-probe", "own-module"]
+            modules = ["iabtl", "own-module"]
 
-            [testing.seam-probe]
+            [testing.iabtl]
             country = "ZZ"
             "#,
         );
diff --git a/crates/trusted-server-adapter-axum/tests/shipped_modules.rs b/crates/trusted-server-adapter-axum/tests/shipped_modules.rs
new file mode 100644
index 0000000000..f0b06fcc30
--- /dev/null
+++ b/crates/trusted-server-adapter-axum/tests/shipped_modules.rs
@@ -0,0 +1,511 @@
+//! What the module builders the Axum adapter links give a deployment, proven
+//! from outside the adapter: each module's own deploy rules and secret
+//! settings, the diagnostics module's request preparer, the middleware the
+//! template and the guide document, the ad server's decision between planned
+//! bids, and the maintainers every crate outside core names.
+
+#![allow(clippy::panic, reason = "tests use panic-on-failure helpers")]
+
+use trusted_server_adapter_axum::app::shipped_module_builders;
+use trusted_server_core::integrations::{
+    IntegrationRegistry, SuppliedMiddleware, supplied_middleware,
+};
+use trusted_server_core::middleware::{HTML_MEDIA_TYPE, MiddlewarePhase};
+
+/// The middleware the linked modules and core supply, with the integration
+/// that supplies each, in the order the registry registers them.
+fn listed_middleware() -> Vec<(&'static str, SuppliedMiddleware)> {
+    supplied_middleware(&shipped_module_builders())
+}
+
+/// The `ts` tool registers the builders it links, so validating a
+/// deployment's settings before a push runs each module's own rules.
+#[test]
+fn deploy_validation_runs_a_linked_module_s_own_rules() {
+    use serde_json::json;
+    use trusted_server_core::config::{TrustedServerAppConfig, register_deploy_integrations};
+    use trusted_server_core::test_support::tests::create_test_settings;
+
+    register_deploy_integrations(shipped_module_builders());
+
+    TrustedServerAppConfig::new(create_test_settings())
+        .expect("should accept the settings before a module's table is wrong");
+
+    let mut settings = create_test_settings();
+    settings
+        .insert_module_config(
+            "cmp",
+            trusted_server_cmp_osano::MODULE,
+            &json!({ "typo": true }),
+        )
+        .expect("should insert the module's table");
+
+    let error = TrustedServerAppConfig::new(settings)
+        .expect_err("should refuse a table the module's own rules reject");
+
+    let rendered = format!("{error:?}");
+    assert!(
+        rendered.contains("[cmp.osano]"),
+        "should name the module's table: {rendered}"
+    );
+}
+
+/// The `ts` tool registers the builders it links, so the secret settings a
+/// module declares are among the leaves a push treats as naming a key.
+#[test]
+fn a_linked_module_s_secret_settings_are_listed_once_the_list_is_registered() {
+    use edgezero_core::app_config::AppConfigMeta as _;
+    use trusted_server_core::config::{TrustedServerAppConfig, register_deploy_integrations};
+
+    register_deploy_integrations(shipped_module_builders());
+
+    let paths = TrustedServerAppConfig::secret_fields()
+        .iter()
+        .map(edgezero_core::app_config::SecretField::dotted_path)
+        .collect::<Vec<_>>();
+
+    for expected in [
+        "bot-protection.datadome.server_side_key_secret_name",
+        "bot-protection.datadome.protection_test_bypass.credential_secret_name",
+    ] {
+        assert!(
+            paths.iter().any(|path| path == expected),
+            "should list `{expected}` among {paths:?}"
+        );
+    }
+}
+
+/// Every documented table should be push-ready, so uncommenting its
+/// section's selection and the table with the shown values must parse and
+/// pass field validation. Tables that ship a deliberately invalid
+/// placeholder that is not a secret (the Google Tag Manager `container_id`)
+/// are left out.
+#[test]
+fn documented_module_tables_validate_when_uncommented_and_selected() {
+    use trusted_server_audience_permutive as permutive;
+    use trusted_server_cmp_sourcepoint as sourcepoint;
+    use trusted_server_core::settings::Settings;
+    use trusted_server_core::test_support::template::{
+        template_with_resolved_required_secrets, uncomment_block,
+    };
+    use trusted_server_identity_lockr as lockr;
+
+    let base = template_with_resolved_required_secrets();
+
+    for (section, selection, header, name) in [
+        (
+            "[audience]",
+            "module = \"permutive\"",
+            "[audience.permutive]",
+            permutive::MODULE,
+        ),
+        (
+            "[identity]",
+            "module = \"lockr\"",
+            "[identity.lockr]",
+            lockr::MODULE,
+        ),
+        (
+            "[cmp]",
+            "module = \"sourcepoint\"",
+            "[cmp.sourcepoint]",
+            sourcepoint::MODULE,
+        ),
+    ] {
+        let toml = format!(
+            "{}\n{section}\n{selection}\n",
+            uncomment_block(&base, header)
+        );
+        let settings = Settings::from_toml(&toml)
+            .unwrap_or_else(|err| panic!("uncommented {header} should parse: {err:?}"));
+
+        let valid = match name {
+            permutive::MODULE => settings
+                .module_config::<permutive::PermutiveConfig>(name)
+                .unwrap_or_else(|err| panic!("{header} should validate: {err:?}"))
+                .is_some(),
+            lockr::MODULE => settings
+                .module_config::<lockr::LockrConfig>(name)
+                .unwrap_or_else(|err| panic!("{header} should validate: {err:?}"))
+                .is_some(),
+            _ => settings
+                .module_config::<sourcepoint::SourcepointConfig>(name)
+                .unwrap_or_else(|err| panic!("{header} should validate: {err:?}"))
+                .is_some(),
+        };
+        assert!(valid, "{header} should resolve to a valid config");
+    }
+}
+
+/// Every linked page module refuses a setting it does not know, so a
+/// misspelt key in its table fails deploy validation naming the table and
+/// the key, where it would otherwise be ignored.
+#[test]
+fn every_linked_module_rejects_a_setting_it_does_not_know() {
+    use serde_json::json;
+    use trusted_server_core::config::validate_settings_for_deploy_with;
+    use trusted_server_core::module_name::short_form;
+    use trusted_server_core::test_support::tests::create_test_settings;
+
+    let linked = shipped_module_builders();
+    for builder in linked
+        .iter()
+        .filter(|builder| builder.supplies_integration())
+    {
+        let name = builder
+            .module_name()
+            .expect("every linked page module names itself");
+        let section = builder
+            .section()
+            .expect("every linked page module has a section");
+        let mut settings = create_test_settings();
+        settings
+            .insert_module_config(section, name, &json!({ "no_such_setting": true }))
+            .expect("should insert the planted table");
+
+        let error = match validate_settings_for_deploy_with(&settings, &linked) {
+            Ok(()) => panic!("`{name}` should refuse a setting it does not know"),
+            Err(error) => format!("{error:?}"),
+        };
+        let written = short_form(section, name);
+        assert!(
+            error.contains(&format!("[{section}.{written}]")) && error.contains("no_such_setting"),
+            "`{name}` should name its table and the unknown setting: {error}"
+        );
+    }
+}
+
+/// The adapter runs the registry's request preparers and names no module, so
+/// the linked list is what attaches the diagnostics module's preparer. It
+/// strips the module's reserved query and cookie in a deployment that does
+/// not select the module, as it does in one that does.
+#[test]
+fn the_linked_list_attaches_the_diagnostics_module_s_request_preparer() {
+    use edgezero_core::body::Body as EdgeBody;
+    use edgezero_core::http::{Method, header, request_builder};
+    use trusted_server_core::test_support::tests::create_test_settings;
+
+    let settings = create_test_settings();
+    let registry = IntegrationRegistry::with_registrations(&settings, &shipped_module_builders())
+        .expect("should build registry");
+    let mut request = request_builder()
+        .method(Method::GET)
+        .uri("https://publisher.example.com/article?ts_console=1&keep=yes")
+        .header(header::COOKIE, "__Host-ts-console=1; keep-me=yes")
+        .body(EdgeBody::empty())
+        .expect("should build request");
+
+    registry
+        .prepare_request(&settings, &mut request)
+        .expect("should run the linked preparers");
+
+    assert_eq!(
+        request.uri().query(),
+        Some("keep=yes"),
+        "should strip the reserved diagnostics query and keep the rest"
+    );
+    assert_eq!(
+        request
+            .headers()
+            .get(header::COOKIE)
+            .map(|value| value.to_str().expect("cookie should be text")),
+        Some("keep-me=yes"),
+        "should strip the reserved diagnostics cookie and keep the rest"
+    );
+}
+
+/// The template's entries name every middleware the linked modules and core
+/// supply, in the order the registry registers them, which is the order a
+/// deployment that runs them all names them in.
+#[test]
+fn the_template_s_entries_name_the_listed_middleware() {
+    use trusted_server_core::settings::Settings;
+    use trusted_server_core::test_support::template::{
+        template_with_resolved_required_secrets, uncomment_block,
+    };
+
+    let template = uncomment_block(
+        &uncomment_block(&template_with_resolved_required_secrets(), "[[fetch]]"),
+        "[[serve]]",
+    );
+    let settings =
+        Settings::from_toml(&template).expect("should load the template with its entries");
+    let listed = listed_middleware();
+
+    for phase in MiddlewarePhase::ALL {
+        let entries = settings.phase_entries(phase).entries();
+        let mut media_types: Vec<&str> = Vec::new();
+        for (_, row) in listed.iter().filter(|(_, row)| row.phase == phase) {
+            if !media_types.contains(&row.media_type) {
+                media_types.push(row.media_type);
+            }
+        }
+        for media_type in media_types {
+            let named_in_list: Vec<&str> = listed
+                .iter()
+                .filter(|(_, row)| row.phase == phase && row.media_type == media_type)
+                .map(|(_, row)| row.name)
+                .collect();
+            let covering: Vec<_> = entries
+                .iter()
+                .filter(|entry| entry.media_type == media_type)
+                .collect();
+            if media_type == HTML_MEDIA_TYPE || covering.iter().any(|entry| entry.path.is_none()) {
+                // One entry covers every page, for HTML and for a media
+                // type a page's own responses come in.
+                assert_eq!(
+                    covering.len(),
+                    1,
+                    "should document one [[{phase}]] entry for {media_type}"
+                );
+                assert!(
+                    covering[0].path.is_none(),
+                    "should document the [[{phase}]] entry that covers every page"
+                );
+            } else {
+                // A file's middleware is placed on the file's own path, one
+                // entry for each file.
+                assert!(
+                    !covering.is_empty(),
+                    "should document a [[{phase}]] entry on a path for each {media_type} file"
+                );
+            }
+            let named: Vec<&str> = covering
+                .iter()
+                .flat_map(|entry| entry.middleware.iter().map(String::as_str))
+                .collect();
+            assert_eq!(
+                named, named_in_list,
+                "should document every {phase} middleware the linked modules supply for \
+                 {media_type}, in the listed order"
+            );
+        }
+    }
+}
+
+/// The guide's table of middleware lists what the linked modules and core
+/// supply, each with its phase, in the order the registry registers them.
+#[test]
+fn the_guide_s_table_lists_the_same_middleware() {
+    const GUIDE: &str = include_str!(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/../../docs/guide/configuration.md"
+    ));
+
+    // A row of the table is a name and then the list it is written in.
+    let documented: Vec<(String, String)> = GUIDE
+        .lines()
+        .filter_map(|line| {
+            let mut cells = line.split('|').map(str::trim).skip(1);
+            let name = cells.next()?.strip_prefix('`')?.strip_suffix('`')?;
+            let list = cells.next()?.strip_prefix("`[[")?.strip_suffix("]]`")?;
+            Some((name.to_owned(), list.to_owned()))
+        })
+        .collect();
+    let listed: Vec<(String, String)> = listed_middleware()
+        .iter()
+        .map(|(_, row)| (row.name.to_owned(), row.phase.to_string()))
+        .collect();
+
+    assert_eq!(
+        documented, listed,
+        "should document the middleware the linked modules supply, each with its phase, in \
+         the listed order"
+    );
+}
+
+/// The ad server decides between the bids APS returned, and the winner
+/// keeps the seat the exchange returned, APS's own bidder name and its
+/// renderer.
+#[tokio::test]
+async fn the_ad_server_keeps_an_aps_winner_s_identities_and_renderer() {
+    use std::collections::{BTreeMap, HashMap};
+    use std::sync::Arc;
+
+    use trusted_server_ad_server_iabtl::{AdServerMockProvider, AdServerMockSettings};
+    use trusted_server_core::auction::orchestrator::AuctionOrchestrator;
+    use trusted_server_core::auction::types::{
+        AdFormat, AdSlot, AuctionContext, AuctionRequest, MediaType, PublisherInfo, UserInfo,
+    };
+    use trusted_server_core::platform::test_support::{
+        StubHttpClient, build_services_with_http_client,
+    };
+    use trusted_server_core::provider_table::ProviderList;
+    use trusted_server_core::test_support::tests::create_test_settings;
+
+    let http = Arc::new(StubHttpClient::new());
+    http.push_response(
+        200,
+        serde_json::to_vec(&serde_json::json!({
+            "seatbid": [{"seat": "upstream-seat", "bid": [{
+                "id": "aps-bid", "impid": "fictional-slot", "price": 2.0,
+                "w": 300, "h": 250,
+                "ext": {"creativeurl": "https://creative.example/render", "tagtype": "iframe"}
+            }]}]
+        }))
+        .expect("should serialize APS response"),
+    );
+    http.push_response(
+        200,
+        serde_json::to_vec(&serde_json::json!({
+            "seatbid": [{"seat": "aps_instance", "bid": [{
+                "id": "adserver-aps", "impid": "fictional-slot", "price": 2.0,
+                "adm": "ignored", "w": 300, "h": 250, "crid": "aps-creative"
+            }]}]
+        }))
+        .expect("should serialize adserver response"),
+    );
+    let services = build_services_with_http_client(Arc::clone(&http) as Arc<_>);
+
+    let mut settings = create_test_settings();
+    settings.auction.enabled = true;
+    settings.auction.timeout_ms = 777;
+    let serde_json::Value::Object(aps) = serde_json::json!({
+        "implementation": "auction.aps",
+        "endpoint": "https://aps.example/e/pb/bid",
+        "account_id": "example-account",
+        "timeout_ms": 1000,
+        "routing": "all_eligible",
+    }) else {
+        panic!("should build the APS table");
+    };
+    settings.demand = ProviderList::new(
+        vec!["aps_instance".to_string()],
+        BTreeMap::from([("aps_instance".to_string(), aps)]),
+    );
+    let plan = trusted_server_core::auction::compile_auction_plan_with(
+        &settings,
+        &shipped_module_builders(),
+    )
+    .expect("should compile the planned APS auction");
+    let adserver = AdServerMockProvider::new(
+        "adserver_mock",
+        AdServerMockSettings {
+            endpoint: "https://adserver.example/mediate".to_string(),
+            timeout_ms: 500,
+            ..AdServerMockSettings::default()
+        },
+    );
+    let orchestrator = AuctionOrchestrator::from_plan(Arc::new(plan), Some(Arc::new(adserver)));
+    let request = AuctionRequest {
+        id: "fictional-auction".to_string(),
+        slots: vec![AdSlot {
+            id: "fictional-slot".to_string(),
+            formats: vec![AdFormat {
+                media_type: MediaType::Banner,
+                width: 300,
+                height: 250,
+            }],
+            floor_price: Some(1.0),
+            targeting: HashMap::new(),
+            bidders: HashMap::new(),
+        }],
+        publisher: PublisherInfo {
+            domain: "publisher.example".to_string(),
+            page_url: Some("https://publisher.example/article".to_string()),
+        },
+        user: UserInfo {
+            id: None,
+            consent: None,
+            eids: None,
+        },
+        device: None,
+        site: None,
+        context: HashMap::new(),
+    };
+    let inbound = edgezero_core::http::Request::new(edgezero_core::body::Body::empty());
+    let context = AuctionContext {
+        settings: &settings,
+        request: &inbound,
+        timeout_ms: 777,
+        transport_timeout_ms: 777,
+        provider_responses: None,
+        services: &services,
+    };
+
+    let result = orchestrator
+        .run_auction(&request, &context)
+        .await
+        .expect("should decide planned APS bid");
+
+    let provider_bid = &result.provider_responses[0].bids[0];
+    assert_eq!(result.provider_responses[0].provider, "aps_instance");
+    assert_eq!(provider_bid.returned_seat.as_deref(), Some("upstream-seat"));
+    assert_eq!(provider_bid.bidder, "aps");
+    let winner = &result.winning_bids["fictional-slot"];
+    assert_eq!(winner.returned_seat.as_deref(), Some("upstream-seat"));
+    assert_eq!(winner.bidder, "aps");
+    assert!(winner.renderer.is_some());
+    assert!(winner.creative.is_none());
+    assert_eq!(
+        result
+            .adserver_response
+            .as_ref()
+            .map(|response| response.provider.as_str()),
+        Some("adserver_mock")
+    );
+}
+
+/// Every crate outside core says who maintains it, in the
+/// `[package.metadata.maintainers]` table of its manifest. The manifests
+/// are read from the source tree.
+#[test]
+fn every_crate_outside_core_declares_its_maintainers() {
+    const STATUSES: [&str; 3] = ["vendor owned", "seeking vendor owner", "project owned"];
+
+    let crates = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .expect("should have the crates folder above this crate");
+    let mut manifests = Vec::new();
+    for entry in std::fs::read_dir(crates).expect("should list the crates folder") {
+        let type_folder = entry.expect("should read a folder entry").path();
+        // A crate directly under `crates/` is core, an adapter or a tool.
+        // A module crate is one folder further down, under its type.
+        if !type_folder.is_dir() || type_folder.join("Cargo.toml").is_file() {
+            continue;
+        }
+        for entry in std::fs::read_dir(&type_folder).expect("should list a type folder") {
+            let manifest = entry
+                .expect("should read a folder entry")
+                .path()
+                .join("Cargo.toml");
+            if manifest.is_file() {
+                manifests.push(manifest);
+            }
+        }
+    }
+    assert!(
+        manifests.len() > 20,
+        "should find the module crates, found {}",
+        manifests.len()
+    );
+
+    for manifest in manifests {
+        let text = std::fs::read_to_string(&manifest).expect("should read a manifest");
+        let Some((_, after)) = text.split_once("[package.metadata.maintainers]") else {
+            panic!("{} should declare its maintainers", manifest.display());
+        };
+        let table = after.split("\n[").next().unwrap_or_default();
+        let value = |key: &str| {
+            table.lines().find_map(|line| {
+                line.strip_prefix(key)?
+                    .trim_start()
+                    .strip_prefix('=')?
+                    .trim()
+                    .strip_prefix('"')?
+                    .strip_suffix('"')
+            })
+        };
+        assert!(
+            value("owner").is_some_and(|owner| !owner.is_empty()),
+            "{} should name an owner",
+            manifest.display()
+        );
+        let status = value("status").unwrap_or_default();
+        assert!(
+            STATUSES.contains(&status),
+            "{} should state one of {STATUSES:?}, and states `{status}`",
+            manifest.display()
+        );
+    }
+}
diff --git a/crates/trusted-server-adapter-cloudflare/Cargo.toml b/crates/trusted-server-adapter-cloudflare/Cargo.toml
index 9d10f994a1..324ef21d31 100644
--- a/crates/trusted-server-adapter-cloudflare/Cargo.toml
+++ b/crates/trusted-server-adapter-cloudflare/Cargo.toml
@@ -29,13 +29,31 @@ error-stack = { workspace = true }
 futures = { workspace = true }
 log = { workspace = true }
 serde_json = { workspace = true }
+trusted-server-ad-server-iabtl = { workspace = true }
+trusted-server-ad-tag-google = { workspace = true }
+trusted-server-ads-txt-iabtl = { workspace = true }
+trusted-server-auction-aps = { workspace = true }
+trusted-server-auction-prebid = { workspace = true }
+trusted-server-auction-prebid-server = { workspace = true }
+trusted-server-auction-protocol-openrtb = { workspace = true }
+trusted-server-audience-permutive = { workspace = true }
+trusted-server-bot-protection-datadome = { workspace = true }
+trusted-server-cmp-didomi = { workspace = true }
+trusted-server-cmp-inmobi = { workspace = true }
+trusted-server-cmp-osano = { workspace = true }
+trusted-server-cmp-sourcepoint = { workspace = true }
 trusted-server-core = { workspace = true }
-trusted-server-modules = { workspace = true }
+trusted-server-framework-nextjs = { workspace = true }
+trusted-server-headers-geo = { workspace = true }
+trusted-server-identity-lockr = { workspace = true }
 trusted-server-permission-signal-gpc = { workspace = true }
 trusted-server-permission-signal-gpp = { workspace = true }
 trusted-server-permission-signal-mtm = { workspace = true }
 trusted-server-permission-signal-tcf = { workspace = true }
 trusted-server-permission-signal-us-privacy = { workspace = true }
+trusted-server-tag-google-tag = { workspace = true }
+trusted-server-tag-google-tag-manager = { workspace = true }
+trusted-server-testing-testlight = { workspace = true }
 trusted-server-js = { workspace = true }
 worker = { workspace = true, optional = true }
 
@@ -52,4 +70,4 @@ toml = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 # Test fixture only. It proves the integration seam from outside core and must
 # never reach a production build, so it stays a dev-dependency.
-trusted-server-integration-seam-probe = { path = "../testing/seam-probe" }
+trusted-server-testing-iabtl = { path = "../testing/iabtl" }
diff --git a/crates/trusted-server-adapter-cloudflare/src/app.rs b/crates/trusted-server-adapter-cloudflare/src/app.rs
index 59ff6030bb..688efa51b9 100644
--- a/crates/trusted-server-adapter-cloudflare/src/app.rs
+++ b/crates/trusted-server-adapter-cloudflare/src/app.rs
@@ -158,7 +158,7 @@ async fn load_startup_settings(env: &worker::Env) -> Result<Settings, Report<Tru
         &secret_store,
         &StoreName::from(DEFAULT_SECRET_STORE_ID),
         trusted_server_core::platform::PolicyOrigin::Blob,
-        &trusted_server_modules::builders(),
+        &shipped_module_builders(),
     )
 }
 
@@ -189,7 +189,7 @@ fn build_state_with_settings(
 }
 
 /// Build the application state from explicit settings, composing the modules
-/// a stock build ships with the externally supplied builders in
+/// this adapter links with the externally supplied builders in
 /// `integrations`.
 ///
 /// A deployment that ships a vendor crate calls this to add that crate's
@@ -225,9 +225,9 @@ fn build_state_with_registrations_and_services(
     integrations: &[IntegrationBuilder],
     services: Option<RuntimeServices>,
 ) -> Result<Arc<AppState>, Report<TrustedServerError>> {
-    // The modules a stock build ships come first and the deployment's own
+    // The modules this adapter links come first and the deployment's own
     // follow, which is the order their hooks run in.
-    let integrations = trusted_server_modules::builders_with(integrations);
+    let integrations = module_builders_with(integrations);
     let integrations = integrations.as_slice();
 
     // The plan is compiled with the integrations this adapter was given, so an
@@ -312,6 +312,53 @@ fn shipped_signal_modules()
     ]
 }
 
+/// The module builders this adapter links, in the order their request hooks
+/// run. Offering a module does not run it, because the registry builds a
+/// module only when a section of the settings selects it.
+///
+/// A deployment that wants a different set links a different set, and one
+/// that adds a module of its own hands its builder to [`build_state_with_registrations`], which
+/// runs it after these. None of these offers a loading cache, so a
+/// deployment that wants copies kept hands one the same way.
+#[must_use]
+pub fn shipped_module_builders() -> Vec<IntegrationBuilder> {
+    vec![
+        // Prebid registers from the auction plan, and what it registers runs
+        // ahead of the modules below.
+        trusted_server_auction_prebid::builder(),
+        trusted_server_testing_testlight::builder(),
+        trusted_server_framework_nextjs::builder(),
+        trusted_server_audience_permutive::builder(),
+        trusted_server_identity_lockr::builder(),
+        trusted_server_cmp_didomi::builder(),
+        trusted_server_cmp_inmobi::builder(),
+        trusted_server_cmp_sourcepoint::builder(),
+        trusted_server_cmp_osano::builder(),
+        trusted_server_tag_google_tag::builder(),
+        trusted_server_tag_google_tag_manager::builder(),
+        trusted_server_bot_protection_datadome::builder(),
+        trusted_server_ad_tag_google::builder(),
+        trusted_server_ad_tag_google::diagnostics::builder(),
+        trusted_server_ads_txt_iabtl::builder(),
+        trusted_server_headers_geo::builder(),
+        // Implementations `[demand]` and `[ad-server]` can name, which no
+        // section selects.
+        trusted_server_auction_protocol_openrtb::builder(),
+        trusted_server_auction_prebid_server::builder(),
+        trusted_server_auction_aps::builder(),
+        trusted_server_ad_server_iabtl::builder(),
+    ]
+}
+
+/// The builders this adapter links followed by `extra`, a deployment's own,
+/// which is the order their hooks run in.
+#[must_use]
+pub fn module_builders_with(extra: &[IntegrationBuilder]) -> Vec<IntegrationBuilder> {
+    let mut all = shipped_module_builders();
+    all.extend_from_slice(extra);
+    all
+}
+
 impl AppState {
     /// Build per-request [`RuntimeServices`], carrying the Edge Cookie module
     /// the composition root already resolved and applying the module-supplied
@@ -1285,4 +1332,88 @@ mod tests {
             "startup should log that this adapter sends no auction telemetry"
         );
     }
+
+    /// The modules this adapter links are offered in the order their hooks
+    /// run. A module is named by what its section selects, and an
+    /// implementation by what `[demand]` or `[ad-server]` names.
+    #[test]
+    fn the_linked_modules_are_offered_in_hook_order() {
+        let names: Vec<&str> = shipped_module_builders()
+            .iter()
+            .map(|builder| {
+                builder
+                    .module_name()
+                    .or_else(|| builder.demand().map(|demand| demand.id))
+                    .or_else(|| builder.adserver().map(|adserver| adserver.id))
+                    .unwrap_or_else(|| builder.id())
+            })
+            .collect();
+
+        assert_eq!(
+            names,
+            [
+                "auction.prebid",
+                "testing.testlight",
+                "framework.nextjs",
+                "audience.permutive",
+                "identity.lockr",
+                "cmp.didomi",
+                "cmp.inmobi",
+                "cmp.sourcepoint",
+                "cmp.osano",
+                "tag.google-tag",
+                "tag.google-tag-manager",
+                "bot-protection.datadome",
+                "ad-tag.google",
+                "ad-tag.google.diagnostics",
+                "ads-txt.iabtl",
+                "headers.geo",
+                "auction-protocol.openrtb",
+                "auction.prebid-server",
+                "auction.aps",
+                "ad-server.iabtl",
+            ],
+            "should offer the linked modules in the order their hooks run"
+        );
+    }
+
+    /// This adapter links no loading cache module, so every feature loads
+    /// through `NoLoadingCache`, which keeps no copy, and a deployment that
+    /// wants copies kept hands a loading cache module's builder to it.
+    #[test]
+    fn the_stock_build_links_no_loading_cache() {
+        let offering: Vec<&str> = shipped_module_builders()
+            .iter()
+            .filter(|builder| builder.loading_cache().is_some())
+            .map(IntegrationBuilder::id)
+            .collect();
+
+        assert!(
+            offering.is_empty(),
+            "a stock build should link no loading cache, and links {offering:?}"
+        );
+    }
+
+    /// A deployment's builders follow the ones this adapter links.
+    #[test]
+    fn a_deployment_s_builders_follow_the_linked_ones() {
+        let linked = shipped_module_builders().len();
+        let extra = [IntegrationBuilder::implementations(
+            "deployment_fixture",
+            "deployment-crate",
+        )];
+
+        let all = module_builders_with(&extra);
+
+        assert_eq!(
+            all.len(),
+            linked + 1,
+            "should keep every linked builder and add the deployment's"
+        );
+        assert_eq!(
+            all.last().map(IntegrationBuilder::source),
+            Some("deployment-crate"),
+            "should put the deployment's builder last"
+        );
+    }
 }
diff --git a/crates/trusted-server-adapter-cloudflare/tests/routes.rs b/crates/trusted-server-adapter-cloudflare/tests/routes.rs
index 39459690aa..bb0670fd53 100644
--- a/crates/trusted-server-adapter-cloudflare/tests/routes.rs
+++ b/crates/trusted-server-adapter-cloudflare/tests/routes.rs
@@ -565,7 +565,7 @@ mod module_endpoints {
     };
     use trusted_server_core::module_context::ModuleCall;
     use trusted_server_core::settings::Settings;
-    use trusted_server_integration_seam_probe as seam_probe;
+    use trusted_server_testing_iabtl as seam_probe;
 
     /// The inspection page's path, which this adapter answers for `GET`.
     const CONFIG_PAGE_PATH: &str = "/_ts/config";
@@ -582,9 +582,9 @@ mod module_endpoints {
     /// The probe's own section and table.
     const PROBE_BLOCK: &str = r#"
         [testing]
-        modules = ["seam-probe"]
+        modules = ["iabtl"]
 
-        [testing.seam-probe]
+        [testing.iabtl]
         country = "ZZ"
     "#;
 
@@ -793,9 +793,9 @@ mod module_endpoints {
         let settings = settings_with(
             r#"
             [testing]
-            modules = ["seam-probe", "own-module"]
+            modules = ["iabtl", "own-module"]
 
-            [testing.seam-probe]
+            [testing.iabtl]
             country = "ZZ"
             "#,
         );
diff --git a/crates/trusted-server-adapter-fastly/Cargo.toml b/crates/trusted-server-adapter-fastly/Cargo.toml
index d50065ee5d..512d816322 100644
--- a/crates/trusted-server-adapter-fastly/Cargo.toml
+++ b/crates/trusted-server-adapter-fastly/Cargo.toml
@@ -33,13 +33,31 @@ log = { workspace = true }
 log-fastly = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+trusted-server-ad-server-iabtl = { workspace = true }
+trusted-server-ad-tag-google = { workspace = true }
+trusted-server-ads-txt-iabtl = { workspace = true }
+trusted-server-auction-aps = { workspace = true }
+trusted-server-auction-prebid = { workspace = true }
+trusted-server-auction-prebid-server = { workspace = true }
+trusted-server-auction-protocol-openrtb = { workspace = true }
+trusted-server-audience-permutive = { workspace = true }
+trusted-server-bot-protection-datadome = { workspace = true }
+trusted-server-cmp-didomi = { workspace = true }
+trusted-server-cmp-inmobi = { workspace = true }
+trusted-server-cmp-osano = { workspace = true }
+trusted-server-cmp-sourcepoint = { workspace = true }
 trusted-server-core = { workspace = true }
-trusted-server-modules = { workspace = true }
+trusted-server-framework-nextjs = { workspace = true }
+trusted-server-headers-geo = { workspace = true }
+trusted-server-identity-lockr = { workspace = true }
 trusted-server-permission-signal-gpc = { workspace = true }
 trusted-server-permission-signal-gpp = { workspace = true }
 trusted-server-permission-signal-mtm = { workspace = true }
 trusted-server-permission-signal-tcf = { workspace = true }
 trusted-server-permission-signal-us-privacy = { workspace = true }
+trusted-server-tag-google-tag = { workspace = true }
+trusted-server-tag-google-tag-manager = { workspace = true }
+trusted-server-testing-testlight = { workspace = true }
 trusted-server-device-fastly = { workspace = true }
 trusted-server-geo-fastly = { workspace = true }
 urlencoding = { workspace = true }
@@ -51,4 +69,4 @@ toml = { workspace = true }
 trusted-server-core = { workspace = true, features = ["test-utils"] }
 # Test fixture only. It proves the integration seam on this adapter from
 # outside core and must never be a regular dependency.
-trusted-server-integration-seam-probe = { path = "../testing/seam-probe" }
+trusted-server-testing-iabtl = { path = "../testing/iabtl" }
diff --git a/crates/trusted-server-adapter-fastly/src/app.rs b/crates/trusted-server-adapter-fastly/src/app.rs
index a9ec7cf59e..f96641a9a5 100644
--- a/crates/trusted-server-adapter-fastly/src/app.rs
+++ b/crates/trusted-server-adapter-fastly/src/app.rs
@@ -243,7 +243,7 @@ pub(crate) fn load_settings_from_config_store(
     } else {
         PolicyOrigin::Source(&entries)
     };
-    // The settings are validated as they load, so the stock builders and the
+    // The settings are validated as they load, so the linked builders and the
     // ones a deployment registered are supplied here as well as to the state
     // build. Without them a `[demand]` or `[ad-server]` name one of them
     // supplies is refused before the state that knows them is built.
@@ -254,7 +254,7 @@ pub(crate) fn load_settings_from_config_store(
         &stores.config_key,
         &stores.secret_store_name,
         policy_origin,
-        &trusted_server_modules::builders_with(registered_integrations()),
+        &module_builders_with(registered_integrations()),
     )
 }
 
@@ -302,7 +302,7 @@ fn registered_integrations() -> &'static [IntegrationBuilder] {
 }
 
 /// Build the application state from explicit settings, composing the modules
-/// a stock build ships with the externally supplied builders in
+/// this adapter links with the externally supplied builders in
 /// `integrations`.
 ///
 /// A deployment that ships a vendor crate calls this to add that crate's
@@ -323,9 +323,9 @@ pub(crate) fn build_state_with_registrations(
 ) -> Result<Arc<AppState>, Report<TrustedServerError>> {
     warn_if_certificate_check_disabled(&settings);
 
-    // The modules a stock build ships come first and the deployment's own
+    // The modules this adapter links come first and the deployment's own
     // follow, which is the order their hooks run in.
-    let integrations = trusted_server_modules::builders_with(integrations);
+    let integrations = module_builders_with(integrations);
     let integrations = integrations.as_slice();
 
     // The plan is compiled with the integrations this adapter was given, so an
@@ -420,6 +420,53 @@ fn shipped_signal_modules()
     ]
 }
 
+/// The module builders this adapter links, in the order their request hooks
+/// run. Offering a module does not run it, because the registry builds a
+/// module only when a section of the settings selects it.
+///
+/// A deployment that wants a different set links a different set, and one
+/// that adds a module of its own hands its builder to [`crate::run_with`], which
+/// runs it after these. None of these offers a loading cache, so a
+/// deployment that wants copies kept hands one the same way.
+#[must_use]
+pub fn shipped_module_builders() -> Vec<IntegrationBuilder> {
+    vec![
+        // Prebid registers from the auction plan, and what it registers runs
+        // ahead of the modules below.
+        trusted_server_auction_prebid::builder(),
+        trusted_server_testing_testlight::builder(),
+        trusted_server_framework_nextjs::builder(),
+        trusted_server_audience_permutive::builder(),
+        trusted_server_identity_lockr::builder(),
+        trusted_server_cmp_didomi::builder(),
+        trusted_server_cmp_inmobi::builder(),
+        trusted_server_cmp_sourcepoint::builder(),
+        trusted_server_cmp_osano::builder(),
+        trusted_server_tag_google_tag::builder(),
+        trusted_server_tag_google_tag_manager::builder(),
+        trusted_server_bot_protection_datadome::builder(),
+        trusted_server_ad_tag_google::builder(),
+        trusted_server_ad_tag_google::diagnostics::builder(),
+        trusted_server_ads_txt_iabtl::builder(),
+        trusted_server_headers_geo::builder(),
+        // Implementations `[demand]` and `[ad-server]` can name, which no
+        // section selects.
+        trusted_server_auction_protocol_openrtb::builder(),
+        trusted_server_auction_prebid_server::builder(),
+        trusted_server_auction_aps::builder(),
+        trusted_server_ad_server_iabtl::builder(),
+    ]
+}
+
+/// The builders this adapter links followed by `extra`, a deployment's own,
+/// which is the order their hooks run in.
+#[must_use]
+pub fn module_builders_with(extra: &[IntegrationBuilder]) -> Vec<IntegrationBuilder> {
+    let mut all = shipped_module_builders();
+    all.extend_from_slice(extra);
+    all
+}
+
 fn warn_if_certificate_check_disabled(settings: &Settings) {
     if !settings.proxy.certificate_check {
         log::warn!(
@@ -1680,9 +1727,10 @@ mod tests {
     use std::sync::{Arc, Mutex};
 
     use super::{
-        AppState, DEFAULT_CONFIG_STORE_ID, EidSyncSource, NAMED_ROUTES, NamedRouteHandler,
-        PAGE_BIDS_LEGACY_PATH, PAGE_BIDS_PATH, RuntimeStoreConfig, TrustedServerApp,
-        blob_carries_its_policy, build_per_request_services, build_state_from_settings,
+        AppState, DEFAULT_CONFIG_STORE_ID, EidSyncSource, IntegrationBuilder, NAMED_ROUTES,
+        NamedRouteHandler, PAGE_BIDS_LEGACY_PATH, PAGE_BIDS_PATH, RuntimeStoreConfig,
+        TrustedServerApp, blob_carries_its_policy, build_per_request_services,
+        build_state_from_settings, module_builders_with, shipped_module_builders,
         startup_error_router,
     };
     use bytes::Bytes;
@@ -1961,7 +2009,7 @@ mod tests {
     ) -> RouterService {
         let settings = test_settings();
         let plan = Arc::new(
-            compile_auction_plan_with(&settings, &trusted_server_modules::builders())
+            compile_auction_plan_with(&settings, &shipped_module_builders())
                 .expect("should compile auction plan"),
         );
         let orchestrator = trusted_server_core::auction::build_orchestrator_with_plan(plan)
@@ -3446,4 +3494,88 @@ mod tests {
             "an origin-start failure must not authorize orphan recovery"
         );
     }
+
+    /// The modules this adapter links are offered in the order their hooks
+    /// run. A module is named by what its section selects, and an
+    /// implementation by what `[demand]` or `[ad-server]` names.
+    #[test]
+    fn the_linked_modules_are_offered_in_hook_order() {
+        let names: Vec<&str> = shipped_module_builders()
+            .iter()
+            .map(|builder| {
+                builder
+                    .module_name()
+                    .or_else(|| builder.demand().map(|demand| demand.id))
+                    .or_else(|| builder.adserver().map(|adserver| adserver.id))
+                    .unwrap_or_else(|| builder.id())
+            })
+            .collect();
+
+        assert_eq!(
+            names,
+            [
+                "auction.prebid",
+                "testing.testlight",
+                "framework.nextjs",
+                "audience.permutive",
+                "identity.lockr",
+                "cmp.didomi",
+                "cmp.inmobi",
+                "cmp.sourcepoint",
+                "cmp.osano",
+                "tag.google-tag",
+                "tag.google-tag-manager",
+                "bot-protection.datadome",
+                "ad-tag.google",
+                "ad-tag.google.diagnostics",
+                "ads-txt.iabtl",
+                "headers.geo",
+                "auction-protocol.openrtb",
+                "auction.prebid-server",
+                "auction.aps",
+                "ad-server.iabtl",
+            ],
+            "should offer the linked modules in the order their hooks run"
+        );
+    }
+
+    /// This adapter links no loading cache module, so every feature loads
+    /// through `NoLoadingCache`, which keeps no copy, and a deployment that
+    /// wants copies kept hands a loading cache module's builder to it.
+    #[test]
+    fn the_stock_build_links_no_loading_cache() {
+        let offering: Vec<&str> = shipped_module_builders()
+            .iter()
+            .filter(|builder| builder.loading_cache().is_some())
+            .map(IntegrationBuilder::id)
+            .collect();
+
+        assert!(
+            offering.is_empty(),
+            "a stock build should link no loading cache, and links {offering:?}"
+        );
+    }
+
+    /// A deployment's builders follow the ones this adapter links.
+    #[test]
+    fn a_deployment_s_builders_follow_the_linked_ones() {
+        let linked = shipped_module_builders().len();
+        let extra = [IntegrationBuilder::implementations(
+            "deployment_fixture",
+            "deployment-crate",
+        )];
+
+        let all = module_builders_with(&extra);
+
+        assert_eq!(
+            all.len(),
+            linked + 1,
+            "should keep every linked builder and add the deployment's"
+        );
+        assert_eq!(
+            all.last().map(IntegrationBuilder::source),
+            Some("deployment-crate"),
+            "should put the deployment's builder last"
+        );
+    }
 }
diff --git a/crates/trusted-server-adapter-fastly/src/app/seam_probe_tests.rs b/crates/trusted-server-adapter-fastly/src/app/seam_probe_tests.rs
index b401c61a88..450141382d 100644
--- a/crates/trusted-server-adapter-fastly/src/app/seam_probe_tests.rs
+++ b/crates/trusted-server-adapter-fastly/src/app/seam_probe_tests.rs
@@ -1,7 +1,7 @@
 //! Round-trip tests for the integration seam on the Fastly adapter, driven by
 //! a crate `trusted-server-core` knows nothing about.
 //!
-//! `trusted-server-integration-seam-probe` registers every capability the seam
+//! `trusted-server-testing-iabtl` registers every capability the seam
 //! exposes, and each test asserts an observable outcome through this adapter's
 //! own router: the bytes served, the JSON a route returns, or the error a
 //! startup check produces. The Axum adapter's seam tests assert the same
@@ -23,7 +23,7 @@ use trusted_server_core::platform::{GeoInfo, GeoModule, PlatformError};
 use trusted_server_core::settings::Settings;
 use trusted_server_core::tsjs::tsjs_script_src;
 use trusted_server_core::tsjs_bundle::{JsModulePart, compile_time_parts};
-use trusted_server_integration_seam_probe as seam_probe;
+use trusted_server_testing_iabtl as seam_probe;
 
 use super::{
     AppState, TrustedServerApp, build_entry_point_services, build_state_from_settings,
@@ -37,9 +37,9 @@ const MAX_BODY_BYTES: usize = 4 * 1024 * 1024;
 /// assertions expect.
 const PROBE_BLOCK: &str = r#"
         [testing]
-        modules = ["seam-probe"]
+        modules = ["iabtl"]
 
-        [testing.seam-probe]
+        [testing.iabtl]
         country = "ZZ"
 "#;
 
@@ -183,7 +183,7 @@ fn proxy_route_reports_the_modules_geo_and_that_the_preparer_ran() {
     let settings = settings_with(&format!(
         r#"
         [geo]
-        module = "testing.seam-probe"
+        module = "testing.iabtl"
         {HMAC_BLOCK}
         {PROBE_BLOCK}
         "#
@@ -561,7 +561,7 @@ fn fetch_entry_builds_state_only_when_its_middleware_is_running() {
     const ENTRY: &str = r#"
         [[fetch]]
         media_type = "text/html"
-        middleware = ["testing.seam-probe"]
+        middleware = ["testing.iabtl"]
 "#;
 
     let selected = settings_with(&format!("{HMAC_BLOCK}{PROBE_BLOCK}{ENTRY}"));
@@ -577,8 +577,8 @@ fn fetch_entry_builds_state_only_when_its_middleware_is_running() {
 
     let message = error.to_string();
     assert!(
-        message.contains("[[fetch]] entry 1 names `testing.seam-probe`")
-            && message.contains("`testing.seam-probe` is a module no section selects"),
+        message.contains("[[fetch]] entry 1 names `testing.iabtl`")
+            && message.contains("`testing.iabtl` is a module no section selects"),
         "should name the entry and say why the middleware is not running: {message}"
     );
 }
@@ -616,7 +616,7 @@ fn serve_entry_builds_state_only_with_a_middleware_of_that_phase() {
 
     let message = error.to_string();
     assert!(
-        message.contains("[[serve]] entry 1 names `testing.seam-probe`")
+        message.contains("[[serve]] entry 1 names `testing.iabtl`")
             && message.contains("does not run in that phase. It runs in [[fetch]]"),
         "should say which phase the middleware runs in: {message}"
     );
@@ -629,13 +629,13 @@ fn geo_selector_naming_a_module_without_a_geo_module_fails_at_startup() {
     let settings = settings_with(&format!(
         r#"
         [geo]
-        module = "testing.seam-probe"
+        module = "testing.iabtl"
         {HMAC_BLOCK}
 
         [testing]
-        modules = ["seam-probe"]
+        modules = ["iabtl"]
 
-        [testing.seam-probe]
+        [testing.iabtl]
         country = "ZZ"
         declares_geo = false
         "#
@@ -647,7 +647,7 @@ fn geo_selector_naming_a_module_without_a_geo_module_fails_at_startup() {
 
     let message = error.to_string();
     assert!(
-        message.contains("`[geo] module` names `testing.seam-probe`")
+        message.contains("`[geo] module` names `testing.iabtl`")
             && message.contains("is selected and supplies no geo module"),
         "should name the module and the missing capability: {message}"
     );
@@ -903,9 +903,9 @@ mod module_endpoints {
         let settings = settings_with(&format!(
             r#"{HMAC_BLOCK}
         [testing]
-        modules = ["seam-probe", "own-module"]
+        modules = ["iabtl", "own-module"]
 
-        [testing.seam-probe]
+        [testing.iabtl]
         country = "ZZ"
         "#
         ));
@@ -985,7 +985,7 @@ fn demand_source_a_module_supplies_builds_state_only_with_its_builder() {
         modules = ["probe"]
 
         [demand.probe]
-        implementation = "testing.seam-probe"
+        implementation = "testing.iabtl"
         endpoint = "https://demand.example/openrtb2/auction"
         {HMAC_BLOCK}
         "#
@@ -1004,7 +1004,7 @@ fn demand_source_a_module_supplies_builds_state_only_with_its_builder() {
         .expect("should refuse a demand source no builder in the deployment supplies");
     let message = error.to_string();
     assert!(
-        message.contains("[demand] `probe` uses implementation `testing.seam-probe`"),
+        message.contains("[demand] `probe` uses implementation `testing.iabtl`"),
         "should name the demand source and the implementation nothing supplies: {message}"
     );
 }
@@ -1021,7 +1021,7 @@ fn ad_server_a_module_supplies_builds_state_only_with_its_builder() {
         module = "probe"
 
         [ad-server.probe]
-        implementation = "testing.seam-probe"
+        implementation = "testing.iabtl"
         {HMAC_BLOCK}
         "#
         ))
@@ -1039,7 +1039,7 @@ fn ad_server_a_module_supplies_builds_state_only_with_its_builder() {
         .expect("should refuse an ad server no builder in the deployment supplies");
     let message = error.to_string();
     assert!(
-        message.contains("[ad-server] `probe` uses implementation `testing.seam-probe`"),
+        message.contains("[ad-server] `probe` uses implementation `testing.iabtl`"),
         "should name the ad server and the implementation nothing supplies: {message}"
     );
 }
@@ -1053,28 +1053,30 @@ fn ec_and_device_selectors_naming_a_module_resolve_the_modules_it_declares() {
     let settings = settings_with(&format!(
         r#"
         [ec]
-        module = "testing.seam-probe"
+        module = "testing.iabtl"
 
         [device]
-        module = "testing.seam-probe"
+        module = "testing.iabtl"
         {PROBE_BLOCK}
         "#
     ));
 
     let state = state_with(settings, &[seam_probe::builder()]);
 
-    let device = state.registry.device_module().expect(
-        "`[device] module = \"testing.seam-probe\"` should resolve the module's device module",
-    );
+    let device = state
+        .registry
+        .device_module()
+        .expect("`[device] module = \"testing.iabtl\"` should resolve the module's device module");
     assert_eq!(
         device.id(),
         seam_probe::module_name(),
         "the device module should be the one the module declared"
     );
 
-    let module = state.registry.ec_module().expect(
-        "`[ec] module = \"testing.seam-probe\"` should resolve the module's Edge Cookie module",
-    );
+    let module = state
+        .registry
+        .ec_module()
+        .expect("`[ec] module = \"testing.iabtl\"` should resolve the module's Edge Cookie module");
     assert_eq!(
         module.id(),
         seam_probe::module_name(),
@@ -1122,7 +1124,7 @@ fn device_selector_naming_a_module_classifies_a_request_with_it() {
         settings_with(&format!(
             r#"
         [device]
-        module = "testing.seam-probe"
+        module = "testing.iabtl"
         {HMAC_BLOCK}
         {PROBE_BLOCK}
         "#
diff --git a/crates/trusted-server-adapter-fastly/src/lib.rs b/crates/trusted-server-adapter-fastly/src/lib.rs
index 0637eecf2f..bff902f173 100644
--- a/crates/trusted-server-adapter-fastly/src/lib.rs
+++ b/crates/trusted-server-adapter-fastly/src/lib.rs
@@ -60,6 +60,9 @@ use crate::app::{
     AppState, EcFinalizeState, RuntimeStoreConfig, TrustedServerApp, build_entry_point_services,
     load_settings_from_config_store,
 };
+/// The module builders this adapter links, and the same followed by a
+/// deployment's own, for a deployment composing a build of its own.
+pub use crate::app::{module_builders_with, shipped_module_builders};
 use crate::ec_kv::FastlyEcKvStore;
 use crate::middleware::{HEADER_X_TS_FINALIZED, apply_finalize_headers};
 use crate::platform::client_info_from_request;
diff --git a/crates/trusted-server-adapter-spin/Cargo.toml b/crates/trusted-server-adapter-spin/Cargo.toml
index 8b5c6b95f8..8a10f977ae 100644
--- a/crates/trusted-server-adapter-spin/Cargo.toml
+++ b/crates/trusted-server-adapter-spin/Cargo.toml
@@ -31,13 +31,31 @@ flate2 = { workspace = true }
 futures = { workspace = true }
 http-body-util = { workspace = true }
 log = { workspace = true }
+trusted-server-ad-server-iabtl = { workspace = true }
+trusted-server-ad-tag-google = { workspace = true }
+trusted-server-ads-txt-iabtl = { workspace = true }
+trusted-server-auction-aps = { workspace = true }
+trusted-server-auction-prebid = { workspace = true }
+trusted-server-auction-prebid-server = { workspace = true }
+trusted-server-auction-protocol-openrtb = { workspace = true }
+trusted-server-audience-permutive = { workspace = true }
+trusted-server-bot-protection-datadome = { workspace = true }
+trusted-server-cmp-didomi = { workspace = true }
+trusted-server-cmp-inmobi = { workspace = true }
+trusted-server-cmp-osano = { workspace = true }
+trusted-server-cmp-sourcepoint = { workspace = true }
 trusted-server-core = { workspace = true }
-trusted-server-modules = { workspace = true }
+trusted-server-framework-nextjs = { workspace = true }
+trusted-server-headers-geo = { workspace = true }
+trusted-server-identity-lockr = { workspace = true }
 trusted-server-permission-signal-gpc = { workspace = true }
 trusted-server-permission-signal-gpp = { workspace = true }
 trusted-server-permission-signal-mtm = { workspace = true }
 trusted-server-permission-signal-tcf = { workspace = true }
 trusted-server-permission-signal-us-privacy = { workspace = true }
+trusted-server-tag-google-tag = { workspace = true }
+trusted-server-tag-google-tag-manager = { workspace = true }
+trusted-server-testing-testlight = { workspace = true }
 trusted-server-js = { workspace = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
@@ -51,4 +69,4 @@ serde_json = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 # Test fixture only. It proves the integration seam from outside core and must
 # never reach a production build, so it stays a dev-dependency.
-trusted-server-integration-seam-probe = { path = "../testing/seam-probe" }
+trusted-server-testing-iabtl = { path = "../testing/iabtl" }
diff --git a/crates/trusted-server-adapter-spin/src/app.rs b/crates/trusted-server-adapter-spin/src/app.rs
index 8255dbc15f..875d637d37 100644
--- a/crates/trusted-server-adapter-spin/src/app.rs
+++ b/crates/trusted-server-adapter-spin/src/app.rs
@@ -151,7 +151,7 @@ fn load_startup_settings() -> Result<Settings, Report<TrustedServerError>> {
         &secret_store,
         &default_secret_store_name(),
         trusted_server_core::platform::PolicyOrigin::Blob,
-        &trusted_server_modules::builders(),
+        &shipped_module_builders(),
     )
 }
 
@@ -177,7 +177,7 @@ fn build_state_with_settings(
 }
 
 /// Build the application state from explicit settings, composing the modules
-/// a stock build ships with the externally supplied builders in
+/// this adapter links with the externally supplied builders in
 /// `integrations`.
 ///
 /// A deployment that ships a vendor crate calls this to add that crate's
@@ -213,9 +213,9 @@ fn build_state_with_registrations_and_services(
     integrations: &[IntegrationBuilder],
     services: Option<RuntimeServices>,
 ) -> Result<Arc<AppState>, Report<TrustedServerError>> {
-    // The modules a stock build ships come first and the deployment's own
+    // The modules this adapter links come first and the deployment's own
     // follow, which is the order their hooks run in.
-    let integrations = trusted_server_modules::builders_with(integrations);
+    let integrations = module_builders_with(integrations);
     let integrations = integrations.as_slice();
 
     // The plan is compiled with the integrations this adapter was given, so an
@@ -324,6 +324,53 @@ fn shipped_signal_modules()
     ]
 }
 
+/// The module builders this adapter links, in the order their request hooks
+/// run. Offering a module does not run it, because the registry builds a
+/// module only when a section of the settings selects it.
+///
+/// A deployment that wants a different set links a different set, and one
+/// that adds a module of its own hands its builder to [`build_state_with_registrations`], which
+/// runs it after these. None of these offers a loading cache, so a
+/// deployment that wants copies kept hands one the same way.
+#[must_use]
+pub fn shipped_module_builders() -> Vec<IntegrationBuilder> {
+    vec![
+        // Prebid registers from the auction plan, and what it registers runs
+        // ahead of the modules below.
+        trusted_server_auction_prebid::builder(),
+        trusted_server_testing_testlight::builder(),
+        trusted_server_framework_nextjs::builder(),
+        trusted_server_audience_permutive::builder(),
+        trusted_server_identity_lockr::builder(),
+        trusted_server_cmp_didomi::builder(),
+        trusted_server_cmp_inmobi::builder(),
+        trusted_server_cmp_sourcepoint::builder(),
+        trusted_server_cmp_osano::builder(),
+        trusted_server_tag_google_tag::builder(),
+        trusted_server_tag_google_tag_manager::builder(),
+        trusted_server_bot_protection_datadome::builder(),
+        trusted_server_ad_tag_google::builder(),
+        trusted_server_ad_tag_google::diagnostics::builder(),
+        trusted_server_ads_txt_iabtl::builder(),
+        trusted_server_headers_geo::builder(),
+        // Implementations `[demand]` and `[ad-server]` can name, which no
+        // section selects.
+        trusted_server_auction_protocol_openrtb::builder(),
+        trusted_server_auction_prebid_server::builder(),
+        trusted_server_auction_aps::builder(),
+        trusted_server_ad_server_iabtl::builder(),
+    ]
+}
+
+/// The builders this adapter links followed by `extra`, a deployment's own,
+/// which is the order their hooks run in.
+#[must_use]
+pub fn module_builders_with(extra: &[IntegrationBuilder]) -> Vec<IntegrationBuilder> {
+    let mut all = shipped_module_builders();
+    all.extend_from_slice(extra);
+    all
+}
+
 impl AppState {
     /// Build per-request [`RuntimeServices`], carrying the Edge Cookie module
     /// the composition root already resolved and applying the module-supplied
@@ -1890,4 +1937,88 @@ mod tests {
             "startup should log that this adapter sends no auction telemetry"
         );
     }
+
+    /// The modules this adapter links are offered in the order their hooks
+    /// run. A module is named by what its section selects, and an
+    /// implementation by what `[demand]` or `[ad-server]` names.
+    #[test]
+    fn the_linked_modules_are_offered_in_hook_order() {
+        let names: Vec<&str> = shipped_module_builders()
+            .iter()
+            .map(|builder| {
+                builder
+                    .module_name()
+                    .or_else(|| builder.demand().map(|demand| demand.id))
+                    .or_else(|| builder.adserver().map(|adserver| adserver.id))
+                    .unwrap_or_else(|| builder.id())
+            })
+            .collect();
+
+        assert_eq!(
+            names,
+            [
+                "auction.prebid",
+                "testing.testlight",
+                "framework.nextjs",
+                "audience.permutive",
+                "identity.lockr",
+                "cmp.didomi",
+                "cmp.inmobi",
+                "cmp.sourcepoint",
+                "cmp.osano",
+                "tag.google-tag",
+                "tag.google-tag-manager",
+                "bot-protection.datadome",
+                "ad-tag.google",
+                "ad-tag.google.diagnostics",
+                "ads-txt.iabtl",
+                "headers.geo",
+                "auction-protocol.openrtb",
+                "auction.prebid-server",
+                "auction.aps",
+                "ad-server.iabtl",
+            ],
+            "should offer the linked modules in the order their hooks run"
+        );
+    }
+
+    /// This adapter links no loading cache module, so every feature loads
+    /// through `NoLoadingCache`, which keeps no copy, and a deployment that
+    /// wants copies kept hands a loading cache module's builder to it.
+    #[test]
+    fn the_stock_build_links_no_loading_cache() {
+        let offering: Vec<&str> = shipped_module_builders()
+            .iter()
+            .filter(|builder| builder.loading_cache().is_some())
+            .map(IntegrationBuilder::id)
+            .collect();
+
+        assert!(
+            offering.is_empty(),
+            "a stock build should link no loading cache, and links {offering:?}"
+        );
+    }
+
+    /// A deployment's builders follow the ones this adapter links.
+    #[test]
+    fn a_deployment_s_builders_follow_the_linked_ones() {
+        let linked = shipped_module_builders().len();
+        let extra = [IntegrationBuilder::implementations(
+            "deployment_fixture",
+            "deployment-crate",
+        )];
+
+        let all = module_builders_with(&extra);
+
+        assert_eq!(
+            all.len(),
+            linked + 1,
+            "should keep every linked builder and add the deployment's"
+        );
+        assert_eq!(
+            all.last().map(IntegrationBuilder::source),
+            Some("deployment-crate"),
+            "should put the deployment's builder last"
+        );
+    }
 }
diff --git a/crates/trusted-server-adapter-spin/tests/routes.rs b/crates/trusted-server-adapter-spin/tests/routes.rs
index 11032fac92..d52cb8955d 100644
--- a/crates/trusted-server-adapter-spin/tests/routes.rs
+++ b/crates/trusted-server-adapter-spin/tests/routes.rs
@@ -603,7 +603,7 @@ mod module_endpoints {
     };
     use trusted_server_core::module_context::ModuleCall;
     use trusted_server_core::settings::Settings;
-    use trusted_server_integration_seam_probe as seam_probe;
+    use trusted_server_testing_iabtl as seam_probe;
 
     /// The inspection page's path, which this adapter answers for `GET`.
     const CONFIG_PAGE_PATH: &str = "/_ts/config";
@@ -620,9 +620,9 @@ mod module_endpoints {
     /// The probe's own section and table.
     const PROBE_BLOCK: &str = r#"
         [testing]
-        modules = ["seam-probe"]
+        modules = ["iabtl"]
 
-        [testing.seam-probe]
+        [testing.iabtl]
         country = "ZZ"
     "#;
 
@@ -831,9 +831,9 @@ mod module_endpoints {
         let settings = settings_with(
             r#"
             [testing]
-            modules = ["seam-probe", "own-module"]
+            modules = ["iabtl", "own-module"]
 
-            [testing.seam-probe]
+            [testing.iabtl]
             country = "ZZ"
             "#,
         );
diff --git a/crates/trusted-server-cli/Cargo.toml b/crates/trusted-server-cli/Cargo.toml
index 604724a5f9..87e034a724 100644
--- a/crates/trusted-server-cli/Cargo.toml
+++ b/crates/trusted-server-cli/Cargo.toml
@@ -58,9 +58,26 @@ tokio = { workspace = true }
 toml = { workspace = true }
 toml_edit = { workspace = true }
 tracing = { workspace = true }
+trusted-server-ad-server-iabtl = { workspace = true }
+trusted-server-ad-tag-google = { workspace = true }
+trusted-server-ads-txt-iabtl = { workspace = true }
+trusted-server-auction-aps = { workspace = true }
+trusted-server-auction-prebid = { workspace = true }
 trusted-server-auction-prebid-server = { workspace = true }
+trusted-server-auction-protocol-openrtb = { workspace = true }
+trusted-server-audience-permutive = { workspace = true }
+trusted-server-bot-protection-datadome = { workspace = true }
+trusted-server-cmp-didomi = { workspace = true }
+trusted-server-cmp-inmobi = { workspace = true }
+trusted-server-cmp-osano = { workspace = true }
+trusted-server-cmp-sourcepoint = { workspace = true }
 trusted-server-core = { workspace = true }
-trusted-server-modules = { workspace = true }
+trusted-server-framework-nextjs = { workspace = true }
+trusted-server-headers-geo = { workspace = true }
+trusted-server-identity-lockr = { workspace = true }
+trusted-server-tag-google-tag = { workspace = true }
+trusted-server-tag-google-tag-manager = { workspace = true }
+trusted-server-testing-testlight = { workspace = true }
 url = { workspace = true }
 uuid = { workspace = true }
 which = { workspace = true }
@@ -121,4 +138,3 @@ predicates = { workspace = true }
 temp-env = { workspace = true }
 tempfile = { workspace = true }
 tokio = { workspace = true, features = ["test-util"] }
-trusted-server-auction-prebid = { workspace = true }
diff --git a/crates/trusted-server-cli/src/app_config.rs b/crates/trusted-server-cli/src/app_config.rs
index d4d1386ab1..4ee6c419ea 100644
--- a/crates/trusted-server-cli/src/app_config.rs
+++ b/crates/trusted-server-cli/src/app_config.rs
@@ -11,6 +11,7 @@ use clap::Args;
 use edgezero_core::app_config::{self, AppConfigLoadOptions};
 use edgezero_core::manifest::ManifestLoader;
 use trusted_server_core::config::TrustedServerAppConfig;
+use trusted_server_core::integrations::IntegrationBuilder;
 use trusted_server_core::settings::Settings;
 
 /// Shared local app-config flags accepted by every config/audit ad-template command.
@@ -27,13 +28,49 @@ pub struct AppConfigArgs {
     pub no_env: bool,
 }
 
-/// Registers the modules a stock build ships with deploy validation.
+/// The module builders the `ts` tool links, in the order their request
+/// hooks run, which is the order the adapters link them in. The tool
+/// validates a deployment's settings against each module's own rules and
+/// writes a configuration from what each module says of itself. None offers a
+/// loading cache, as in each adapter's list, so the tool refuses a document
+/// that names one.
+#[must_use]
+pub fn linked_builders() -> Vec<IntegrationBuilder> {
+    vec![
+        // Prebid registers from the auction plan, and what it registers runs
+        // ahead of the modules below.
+        trusted_server_auction_prebid::builder(),
+        trusted_server_testing_testlight::builder(),
+        trusted_server_framework_nextjs::builder(),
+        trusted_server_audience_permutive::builder(),
+        trusted_server_identity_lockr::builder(),
+        trusted_server_cmp_didomi::builder(),
+        trusted_server_cmp_inmobi::builder(),
+        trusted_server_cmp_sourcepoint::builder(),
+        trusted_server_cmp_osano::builder(),
+        trusted_server_tag_google_tag::builder(),
+        trusted_server_tag_google_tag_manager::builder(),
+        trusted_server_bot_protection_datadome::builder(),
+        trusted_server_ad_tag_google::builder(),
+        trusted_server_ad_tag_google::diagnostics::builder(),
+        trusted_server_ads_txt_iabtl::builder(),
+        trusted_server_headers_geo::builder(),
+        // Implementations `[demand]` and `[ad-server]` can name, which no
+        // section selects.
+        trusted_server_auction_protocol_openrtb::builder(),
+        trusted_server_auction_prebid_server::builder(),
+        trusted_server_auction_aps::builder(),
+        trusted_server_ad_server_iabtl::builder(),
+    ]
+}
+
+/// Registers the modules the tool links with deploy validation.
 ///
 /// [`TrustedServerAppConfig`] validates through a trait that takes no
 /// arguments, so every path that validates settings calls this first. The
 /// first call wins and a later one changes nothing.
-pub(crate) fn register_stock_modules() {
-    trusted_server_core::config::register_deploy_integrations(trusted_server_modules::builders());
+pub(crate) fn register_linked_modules() {
+    trusted_server_core::config::register_deploy_integrations(linked_builders());
 }
 
 /// Effective settings plus the resolved app-config path they were loaded from.
@@ -143,7 +180,7 @@ fn load_settings_with_env_overlay(
 
     let mut opts = AppConfigLoadOptions::default();
     opts.env_overlay = env_overlay;
-    register_stock_modules();
+    register_linked_modules();
     let app_config = app_config::deserialize_app_config_with_options::<TrustedServerAppConfig>(
         &resolved.path,
         &resolved.app_name,
@@ -204,4 +241,105 @@ mod tests {
             "error should mention the explicit missing path"
         );
     }
+
+    /// The tool links the modules each adapter links, in the order their hooks
+    /// run, so it validates a deployment's settings as they do. A module is
+    /// named by what its section selects, and an implementation by what
+    /// `[demand]` or `[ad-server]` names.
+    #[test]
+    fn the_linked_modules_are_offered_in_hook_order() {
+        let names: Vec<&str> = linked_builders()
+            .iter()
+            .map(|builder| {
+                builder
+                    .module_name()
+                    .or_else(|| builder.demand().map(|demand| demand.id))
+                    .or_else(|| builder.adserver().map(|adserver| adserver.id))
+                    .unwrap_or_else(|| builder.id())
+            })
+            .collect();
+
+        assert_eq!(
+            names,
+            [
+                "auction.prebid",
+                "testing.testlight",
+                "framework.nextjs",
+                "audience.permutive",
+                "identity.lockr",
+                "cmp.didomi",
+                "cmp.inmobi",
+                "cmp.sourcepoint",
+                "cmp.osano",
+                "tag.google-tag",
+                "tag.google-tag-manager",
+                "bot-protection.datadome",
+                "ad-tag.google",
+                "ad-tag.google.diagnostics",
+                "ads-txt.iabtl",
+                "headers.geo",
+                "auction-protocol.openrtb",
+                "auction.prebid-server",
+                "auction.aps",
+                "ad-server.iabtl",
+            ],
+            "should offer the linked modules in the order their hooks run"
+        );
+    }
+
+    /// The tool links no loading cache module, so `ts config validate`
+    /// refuses a document that names one, as a stock adapter does.
+    #[test]
+    fn the_stock_build_links_no_loading_cache() {
+        let offering: Vec<&str> = linked_builders()
+            .iter()
+            .filter(|builder| builder.loading_cache().is_some())
+            .map(IntegrationBuilder::id)
+            .collect();
+
+        assert!(
+            offering.is_empty(),
+            "a stock build should link no loading cache, and links {offering:?}"
+        );
+    }
+
+    /// `ts config validate` validates with the builders the tool links, so a
+    /// document whose `[cache.<name>]` names a loading cache module is
+    /// refused, and the refusal names the table and says the tool has none.
+    #[test]
+    fn deploy_validation_refuses_a_loading_cache_module_the_tool_does_not_link() {
+        // Deploy validation refuses the example's placeholder addresses as
+        // insecure defaults, so the test gives addresses of its own.
+        let document = include_str!(concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/../../trusted-server.example.toml"
+        ))
+        .replace("domain = \"example.com\"", "domain = \"publisher.example\"")
+        .replace(
+            "cookie_domain = \".example.com\"",
+            "cookie_domain = \".publisher.example\"",
+        )
+        .replace(
+            "url = \"https://origin.example.com\"",
+            "url = \"https://origin.publisher.example\"",
+        );
+        let mut settings =
+            Settings::from_toml(&document).expect("should parse the example settings");
+        settings.cache.robots_txt.module = Some("51degrees".to_owned());
+
+        let error = trusted_server_core::config::validate_settings_for_deploy_with(
+            &settings,
+            &linked_builders(),
+        )
+        .expect_err("a loading cache module the tool does not link should be refused");
+
+        let message = format!("{error:?}");
+        assert!(
+            message.contains(
+                "[cache.robots-txt] module names `51degrees`, which no linked crate offers a \
+                 loading cache from. The loading cache modules this build has are: none"
+            ),
+            "should name the table and say the tool has no loading cache: {message}"
+        );
+    }
 }
diff --git a/crates/trusted-server-cli/src/commands/audit/generate/mod.rs b/crates/trusted-server-cli/src/commands/audit/generate/mod.rs
index 1aa5c5e4c6..90c403341d 100644
--- a/crates/trusted-server-cli/src/commands/audit/generate/mod.rs
+++ b/crates/trusted-server-cli/src/commands/audit/generate/mod.rs
@@ -667,11 +667,25 @@ fn build_google_tag_manager_section(container_id: &str) -> String {
 ///
 /// A module changes a page only where an entry names its middleware, so a
 /// draft that selected a module and wrote no entry would leave the module
-/// changing nothing. The names and their order come from the stock list.
+/// changing nothing. The names and their order come from what the linked
+/// builders describe, in the order the registry registers them. A middleware
+/// for a media type other than HTML is left out, because the entry written
+/// covers every page.
 fn build_page_entries(integration_ids: &[&str]) -> Option<String> {
+    let supplied = trusted_server_core::integrations::supplied_middleware(
+        &crate::app_config::linked_builders(),
+    );
     let mut entries = String::new();
     for phase in MiddlewarePhase::ALL {
-        let names = trusted_server_modules::middleware_for(integration_ids, phase);
+        let names: Vec<&str> = supplied
+            .iter()
+            .filter(|(integration, middleware)| {
+                middleware.phase == phase
+                    && middleware.media_type == trusted_server_core::middleware::HTML_MEDIA_TYPE
+                    && integration_ids.contains(integration)
+            })
+            .map(|(_, middleware)| middleware.name)
+            .collect();
         if names.is_empty() {
             continue;
         }
@@ -709,10 +723,17 @@ fn select_js_asset_proxy(draft: &str) -> CliResult<String> {
 }
 
 /// The section a detected integration's module is selected in, and the name it
-/// is written under there, or `None` for one no module in this build
-/// configures.
+/// is written under there, from the builders the tool links, or `None` for
+/// one no module in this build configures.
 fn module_section(id: &str) -> Option<(&'static str, &'static str)> {
-    trusted_server_modules::selection_of(id)
+    let builder = crate::app_config::linked_builders()
+        .into_iter()
+        .find(|builder| builder.id() == id)?;
+    let section = builder.section()?;
+    Some((
+        section,
+        trusted_server_core::module_name::short_form(section, builder.module_name()?),
+    ))
 }
 
 fn select_js_asset_proxy_candidates(
@@ -4601,4 +4622,34 @@ url = \"https://www.publisher.example:8443\""
             "the concurrent edit must not be overwritten"
         );
     }
+
+    #[test]
+    fn a_module_s_selection_is_found_by_its_integration_id() {
+        for (id, section, written) in [
+            ("prebid", "auction", "prebid"),
+            ("datadome", "bot-protection", "datadome"),
+            ("didomi", "cmp", "didomi"),
+            ("sourcepoint", "cmp", "sourcepoint"),
+            ("osano", "cmp", "osano"),
+            ("lockr", "identity", "lockr"),
+            ("permutive", "audience", "permutive"),
+            ("nextjs", "framework", "nextjs"),
+            ("gpt", "ad-tag", "google"),
+            ("google_tag_manager", "tag", "google-tag-manager"),
+            // Testlight says `[auction]` selects it, where its full name is
+            // written.
+            ("testlight", "auction", "testing.testlight"),
+        ] {
+            assert_eq!(
+                module_section(id),
+                Some((section, written)),
+                "should find where `{id}` is selected"
+            );
+        }
+        assert_eq!(
+            module_section("no-such-integration"),
+            None,
+            "should find nothing for an id no linked module has"
+        );
+    }
 }
diff --git a/crates/trusted-server-cli/src/commands/audit/generate/validate.rs b/crates/trusted-server-cli/src/commands/audit/generate/validate.rs
index 5fa246bc43..9ea724f08f 100644
--- a/crates/trusted-server-cli/src/commands/audit/generate/validate.rs
+++ b/crates/trusted-server-cli/src/commands/audit/generate/validate.rs
@@ -53,7 +53,7 @@ pub(super) fn check_candidate(candidate: &str, baseline: &str) -> CliResult<Vec<
 /// report only the failed phase because their messages can contain literal
 /// values, including validator parameters and invalid patterns.
 fn validate_source_config(source: &str) -> CliResult<()> {
-    crate::app_config::register_stock_modules();
+    crate::app_config::register_linked_modules();
     let config: TrustedServerAppConfig = toml::from_str(source).map_err(|error| {
         error.span().map_or_else(
             || "config could not be loaded".to_string(),
@@ -126,7 +126,7 @@ mod tests {
         );
         let parsed: TrustedServerAppConfig =
             toml::from_str(&invalid).expect("should accept source syntax and schema");
-        crate::app_config::register_stock_modules();
+        crate::app_config::register_linked_modules();
         assert!(
             TrustedServerAppConfig::new(parsed.into_settings()).is_err(),
             "should exercise deploy validation"
diff --git a/crates/trusted-server-cli/src/lib.rs b/crates/trusted-server-cli/src/lib.rs
index 4eb3d09058..908bac617b 100644
--- a/crates/trusted-server-cli/src/lib.rs
+++ b/crates/trusted-server-cli/src/lib.rs
@@ -15,6 +15,8 @@ mod tls;
 #[cfg(not(target_arch = "wasm32"))]
 mod url_guard;
 
+#[cfg(not(target_arch = "wasm32"))]
+pub use app_config::linked_builders;
 #[cfg(not(target_arch = "wasm32"))]
 pub use run::{RunOutcome, run_from_env};
 
diff --git a/crates/trusted-server-cli/src/run.rs b/crates/trusted-server-cli/src/run.rs
index c16fc6ed23..7b3a0265ea 100644
--- a/crates/trusted-server-cli/src/run.rs
+++ b/crates/trusted-server-cli/src/run.rs
@@ -127,7 +127,7 @@ pub fn run_from_env() -> Result<RunOutcome, String> {
 fn dispatch(args: Args) -> Result<RunOutcome, String> {
     // The config commands validate through `EdgeZero`, which reaches the
     // settings' own validation with no way to hand it a list of modules.
-    crate::app_config::register_stock_modules();
+    crate::app_config::register_linked_modules();
     match args.command {
         Command::ActiveVersion(args) => {
             edgezero_cli::run_active_version(&args).map(|()| RunOutcome::Success)
diff --git a/crates/trusted-server-cli/tests/audit_config_diagnostics.rs b/crates/trusted-server-cli/tests/audit_config_diagnostics.rs
index 7e04c15b28..57fa5aaf74 100644
--- a/crates/trusted-server-cli/tests/audit_config_diagnostics.rs
+++ b/crates/trusted-server-cli/tests/audit_config_diagnostics.rs
@@ -12,11 +12,11 @@ use std::time::Duration;
 
 use trusted_server_core::config::TrustedServerAppConfig;
 
-/// Registers the modules a stock build ships with deploy validation, as the
-/// `ts` tool does before it validates, so a configuration validated here is
+/// Registers the modules the `ts` tool links with deploy validation, as the
+/// tool does before it validates, so a configuration validated here is
 /// judged against the modules the tool has.
-fn register_stock_modules() {
-    trusted_server_core::config::register_deploy_integrations(trusted_server_modules::builders());
+fn register_linked_modules() {
+    trusted_server_core::config::register_deploy_integrations(trusted_server_cli::linked_builders());
 }
 
 #[test]
@@ -225,7 +225,7 @@ fn generate_deploy_validation_warning_does_not_echo_baseline_values() {
     );
     let parsed: TrustedServerAppConfig =
         toml::from_str(&source).expect("should pass syntax and schema");
-    register_stock_modules();
+    register_linked_modules();
     assert!(
         TrustedServerAppConfig::new(parsed.into_settings()).is_err(),
         "should fail deploy validation"
@@ -282,7 +282,7 @@ fn generate_deploy_validation_refusal_preserves_config_and_safe_output() {
     let source = format!("{}\n# FICTIONAL_SECRET_SENTINEL\n", baseline());
     let parsed: TrustedServerAppConfig =
         toml::from_str(&source).expect("should parse valid baseline");
-    register_stock_modules();
+    register_linked_modules();
     TrustedServerAppConfig::new(parsed.into_settings()).expect("should pass deploy validation");
     for dry_run in [false, true] {
         let directory = tempfile::tempdir().expect("should create temporary config directory");
diff --git a/crates/trusted-server-cli/tests/config_push_by_key.rs b/crates/trusted-server-cli/tests/config_push_by_key.rs
index aa1853f12a..ee9f381aeb 100644
--- a/crates/trusted-server-cli/tests/config_push_by_key.rs
+++ b/crates/trusted-server-cli/tests/config_push_by_key.rs
@@ -267,7 +267,7 @@ fn read_back(
         key,
         &StoreName::from("trusted_server_secrets"),
         origin,
-        &trusted_server_modules::builders(),
+        &trusted_server_cli::linked_builders(),
     )
 }
 
diff --git a/crates/trusted-server-core/src/auction/README.md b/crates/trusted-server-core/src/auction/README.md
index 5500547f32..d4114c8deb 100644
--- a/crates/trusted-server-core/src/auction/README.md
+++ b/crates/trusted-server-core/src/auction/README.md
@@ -149,17 +149,17 @@ account_id = "example-account"
 module = "pbs_main"
 
 [ad-server]
-module = "mock"
+module = "iabtl"
 
-[ad-server.mock]
+[ad-server.iabtl]
 endpoint = "https://adserver.example.com/decide"
 timeout_ms = 500
 ```
 
 Every demand table carries an `implementation` line naming the
 implementation by its module path, which is how two Prebid Servers run side
-by side under names of their own, and `[ad-server]` writes `ad-server.mock`
-as `mock`. Endpoints must be HTTPS, or HTTP to `127.0.0.1`, `::1` or
+by side under names of their own, and `[ad-server]` writes `ad-server.iabtl`
+as `iabtl`. Endpoints must be HTTPS, or HTTP to `127.0.0.1`, `::1` or
 `localhost`. Replace all example values before enabling an auction.
 
 ## Code map
diff --git a/crates/trusted-server-core/src/auction/context.rs b/crates/trusted-server-core/src/auction/context.rs
index 467801726f..691ac1dc9d 100644
--- a/crates/trusted-server-core/src/auction/context.rs
+++ b/crates/trusted-server-core/src/auction/context.rs
@@ -31,7 +31,7 @@ pub enum ContextValue {
 /// integration-specific knowledge.
 ///
 /// ```toml
-/// [ad-server.mock.context_query_params]
+/// [ad-server.iabtl.context_query_params]
 /// permutive_segments = "permutive"
 /// lockr_ids          = "lockr"
 /// ```
diff --git a/crates/trusted-server-core/src/auction/plan.rs b/crates/trusted-server-core/src/auction/plan.rs
index 49fff990f0..bd3fc11d12 100644
--- a/crates/trusted-server-core/src/auction/plan.rs
+++ b/crates/trusted-server-core/src/auction/plan.rs
@@ -633,8 +633,8 @@ fn configuration_error(message: impl Into<String>) -> Report<TrustedServerError>
 /// The registered implementation `written` names in `[section]`.
 ///
 /// An implementation is named by its module path, which a section named by
-/// the implementation's type folder may shorten, so `mock` in `[ad-server]`
-/// is `ad-server.mock`. The refusal lists what the build has, as the section
+/// the implementation's type folder may shorten, so `iabtl` in `[ad-server]`
+/// is `ad-server.iabtl`. The refusal lists what the build has, as the section
 /// would write it.
 fn resolve_implementation<T>(
     section: &str,
diff --git a/crates/trusted-server-core/src/integrations/js_asset_proxy.rs b/crates/trusted-server-core/src/integrations/js_asset_proxy.rs
index 8ba50ac61f..69d9fca9ab 100644
--- a/crates/trusted-server-core/src/integrations/js_asset_proxy.rs
+++ b/crates/trusted-server-core/src/integrations/js_asset_proxy.rs
@@ -47,7 +47,15 @@ pub(crate) const BUILDER: crate::integrations::IntegrationBuilder =
         validate,
     )
     .with_module_name(MODULE)
-    .selected_in("proxy");
+    .selected_in("proxy")
+    .with_middleware(SUPPLIED_MIDDLEWARE);
+
+/// The page change the module supplies, as an entry names it.
+const SUPPLIED_MIDDLEWARE: &[crate::integrations::SuppliedMiddleware] =
+    &[crate::integrations::SuppliedMiddleware::on_html(
+        MODULE,
+        MiddlewarePhase::Fetch,
+    )];
 const JS_ASSET_CONTENT_TYPE: &str = "application/javascript; charset=utf-8";
 const X_CONTENT_TYPE_OPTIONS_NOSNIFF: &str = "nosniff";
 const ERROR_ORIGIN_UNREACHABLE: &str = "js-asset-origin-unreachable";
@@ -1704,4 +1712,18 @@ mod tests {
             ),
         );
     }
+
+    /// The builder describes the middleware the registration supplies, so a
+    /// tool that writes a configuration places what the module registers.
+    #[test]
+    fn the_builder_describes_the_middleware_the_module_registers() {
+        let settings = crate::html_processor::test_support::page_settings(include_str!(
+            "fixtures/js-asset-proxy.settings.toml"
+        ));
+        crate::test_support::middleware::assert_described_middleware_is_registered(
+            &settings,
+            &[],
+            MODULE,
+        );
+    }
 }
diff --git a/crates/trusted-server-core/src/integrations/mod.rs b/crates/trusted-server-core/src/integrations/mod.rs
index 2d30dcbffc..e1c8b711c3 100644
--- a/crates/trusted-server-core/src/integrations/mod.rs
+++ b/crates/trusted-server-core/src/integrations/mod.rs
@@ -12,6 +12,7 @@ use url::Url;
 use crate::auction::AuctionPlan;
 use crate::auction::demand::{AdServerImplementation, DemandImplementation};
 use crate::error::TrustedServerError;
+use crate::middleware::{HTML_MEDIA_TYPE, MiddlewarePhase};
 use crate::platform::{DEFAULT_FIRST_BYTE_TIMEOUT, PlatformBackendSpec, RuntimeServices};
 use crate::settings::Settings;
 
@@ -364,6 +365,46 @@ pub struct ModuleSecretSetting {
     pub in_use: fn(&serde_json::Map<String, serde_json::Value>) -> bool,
 }
 
+/// A page change a module supplies, as its builder describes it, so a tool
+/// that writes a configuration places the module's page changes without
+/// reading the module.
+///
+/// A middleware that runs in either phase is described in the one a
+/// generated configuration places it in.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SuppliedMiddleware {
+    /// The name an entry writes, which is the middleware's
+    /// [`middleware_id`](crate::middleware::Middleware::middleware_id).
+    pub name: &'static str,
+    /// The phase an entry names it in.
+    pub phase: MiddlewarePhase,
+    /// The media type an entry naming it covers.
+    pub media_type: &'static str,
+}
+
+impl SuppliedMiddleware {
+    /// A page change on every HTML page, named `name` in a `[[phase]]` entry.
+    #[must_use]
+    pub const fn on_html(name: &'static str, phase: MiddlewarePhase) -> Self {
+        Self {
+            name,
+            phase,
+            media_type: HTML_MEDIA_TYPE,
+        }
+    }
+
+    /// A change to a file of `media_type`, named `name` in a `[[phase]]`
+    /// entry on the file's path.
+    #[must_use]
+    pub const fn on(name: &'static str, phase: MiddlewarePhase, media_type: &'static str) -> Self {
+        Self {
+            name,
+            phase,
+            media_type,
+        }
+    }
+}
+
 /// Source label for the built-in integrations.
 pub const CORE_SOURCE: &str = "trusted-server-core";
 
@@ -418,6 +459,7 @@ pub struct IntegrationBuilder {
     plan_validator: Option<IntegrationPlanValidateFn>,
     reads_auction_token: bool,
     secret_settings: &'static [ModuleSecretSetting],
+    middleware: &'static [SuppliedMiddleware],
     supplies_integration: bool,
     demand: Option<&'static DemandImplementation>,
     adserver: Option<&'static AdServerImplementation>,
@@ -465,6 +507,7 @@ impl IntegrationBuilder {
             plan_validator: None,
             reads_auction_token: false,
             secret_settings: &[],
+            middleware: &[],
             supplies_integration: true,
             demand: None,
             adserver: None,
@@ -495,6 +538,7 @@ impl IntegrationBuilder {
             plan_validator: None,
             reads_auction_token: false,
             secret_settings: &[],
+            middleware: &[],
             supplies_integration: false,
             demand: None,
             adserver: None,
@@ -616,6 +660,23 @@ impl IntegrationBuilder {
         self.secret_settings
     }
 
+    /// Describes the page changes the module's registration supplies, each
+    /// with the phase and the media type an entry names it for, so a tool
+    /// that writes a configuration places them without reading the module.
+    /// The registry refuses a registration whose middleware contradicts the
+    /// description.
+    #[must_use]
+    pub const fn with_middleware(mut self, middleware: &'static [SuppliedMiddleware]) -> Self {
+        self.middleware = middleware;
+        self
+    }
+
+    /// The page changes the module's registration supplies, as described.
+    #[must_use]
+    pub const fn middleware(&self) -> &'static [SuppliedMiddleware] {
+        self.middleware
+    }
+
     /// Runs this builder when a section selects the module `name`, which is a
     /// crate's path under `crates` with `.` between the parts, such as
     /// `cmp.example`. An integration still in core holds the name its crate
@@ -763,7 +824,8 @@ impl IntegrationBuilder {
     }
 }
 
-/// The built-in integrations, in the order `trusted-server-modules` lists them.
+/// The built-in integrations, which the registry runs ahead of the builders
+/// a build links.
 const BUILT_IN_BUILDERS: &[IntegrationBuilder] = &[
     // This stays the first module a section selects, so its middleware is
     // the first of theirs in the order the registry lists them.
@@ -813,8 +875,7 @@ const BUILT_IN_BUILDERS: &[IntegrationBuilder] = &[
     .with_adserver(&crate::auction::test_support::adserver_fixture::ADSERVER),
 ];
 
-/// The built-in integration builders, in the order `trusted-server-modules`
-/// lists them.
+/// The built-in integration builders, in the order the registry runs them.
 pub(crate) fn builders() -> &'static [IntegrationBuilder] {
     BUILT_IN_BUILDERS
 }
@@ -827,6 +888,50 @@ pub(crate) fn all_builders(
     builders().iter().copied().chain(extra.iter().copied())
 }
 
+/// The middleware a build of the built-in modules and `builders` supplies,
+/// each with the id of the integration that supplies it, in the order the
+/// registry registers them, which is the order a configuration that runs
+/// them all names them in.
+///
+/// A module registered from the auction plan comes before every module a
+/// section selects, the built-in modules come before `builders`, and core's
+/// robots.txt and service version middleware, which no builder supplies,
+/// come last.
+#[must_use]
+pub fn supplied_middleware(
+    builders: &[IntegrationBuilder],
+) -> Vec<(&'static str, SuppliedMiddleware)> {
+    let described = |builder: IntegrationBuilder| {
+        builder
+            .middleware()
+            .iter()
+            .map(move |middleware| (builder.id(), *middleware))
+    };
+    all_builders(builders)
+        .filter(|builder| builder.plan_registration().is_some())
+        .flat_map(described)
+        .chain(
+            all_builders(builders)
+                .filter(|builder| builder.plan_registration().is_none())
+                .flat_map(described),
+        )
+        .chain([
+            (
+                crate::robots_txt::middleware::MODULE,
+                SuppliedMiddleware::on(
+                    crate::robots_txt::middleware::MODULE,
+                    MiddlewarePhase::Fetch,
+                    crate::robots_txt::middleware::MEDIA_TYPE,
+                ),
+            ),
+            (
+                crate::service_version::MODULE,
+                SuppliedMiddleware::on_html(crate::service_version::MODULE, MiddlewarePhase::Serve),
+            ),
+        ])
+        .collect()
+}
+
 /// The caches a deployment may hold answers in, by name: core's own first,
 /// then the ones `builders` declare, in builder order.
 ///
@@ -1353,3 +1458,156 @@ mod loading_caches_from_tests {
         );
     }
 }
+
+#[cfg(test)]
+mod supplied_middleware_tests {
+    use super::*;
+
+    fn no_build(
+        _settings: &Settings,
+    ) -> Result<Option<IntegrationRegistration>, Report<TrustedServerError>> {
+        Ok(None)
+    }
+
+    fn no_validate(_settings: &Settings) -> Result<bool, Report<TrustedServerError>> {
+        Ok(true)
+    }
+
+    fn no_plan_registration(
+        _settings: &Settings,
+        _plan: &AuctionPlan,
+    ) -> Result<Option<IntegrationRegistration>, Report<TrustedServerError>> {
+        Ok(None)
+    }
+
+    const FIRST: &[SuppliedMiddleware] = &[SuppliedMiddleware::on_html(
+        "testing.first",
+        MiddlewarePhase::Fetch,
+    )];
+    const PLANNED: &[SuppliedMiddleware] = &[
+        SuppliedMiddleware::on_html("testing.planned", MiddlewarePhase::Fetch),
+        SuppliedMiddleware::on_html("testing.planned.reader", MiddlewarePhase::Serve),
+    ];
+    const FILE: &[SuppliedMiddleware] = &[SuppliedMiddleware::on(
+        "testing.file",
+        MiddlewarePhase::Fetch,
+        "text/plain",
+    )];
+
+    #[test]
+    fn a_builder_describes_no_middleware_until_told() {
+        let builder = IntegrationBuilder::new("quiet", CORE_SOURCE, no_build, no_validate);
+
+        assert!(builder.middleware().is_empty());
+        assert_eq!(builder.with_middleware(FIRST).middleware(), FIRST);
+    }
+
+    /// The list follows the registry: what registers from the auction plan
+    /// first, then the built-in modules, then the linked builders in their
+    /// order, then core's robots.txt and service version middleware.
+    #[test]
+    fn the_middleware_are_listed_in_the_order_the_registry_registers_them() {
+        let first = IntegrationBuilder::new("first", CORE_SOURCE, no_build, no_validate)
+            .with_module_name("testing.first")
+            .with_middleware(FIRST);
+        let planned = IntegrationBuilder::new("planned", CORE_SOURCE, no_build, no_validate)
+            .with_module_name("testing.planned")
+            .with_plan_registration(no_plan_registration)
+            .with_middleware(PLANNED);
+        let file = IntegrationBuilder::new("file", CORE_SOURCE, no_build, no_validate)
+            .with_module_name("testing.file")
+            .with_middleware(FILE);
+        let silent = IntegrationBuilder::implementations("silent", CORE_SOURCE);
+
+        let listed = supplied_middleware(&[first, silent, planned, file]);
+
+        let rows: Vec<(&str, &str, MiddlewarePhase, &str)> = listed
+            .iter()
+            .map(|(integration, middleware)| {
+                (
+                    *integration,
+                    middleware.name,
+                    middleware.phase,
+                    middleware.media_type,
+                )
+            })
+            .collect();
+        assert_eq!(
+            rows,
+            [
+                (
+                    "planned",
+                    "testing.planned",
+                    MiddlewarePhase::Fetch,
+                    HTML_MEDIA_TYPE
+                ),
+                (
+                    "planned",
+                    "testing.planned.reader",
+                    MiddlewarePhase::Serve,
+                    HTML_MEDIA_TYPE
+                ),
+                (
+                    js_asset_proxy::MODULE,
+                    js_asset_proxy::MODULE,
+                    MiddlewarePhase::Fetch,
+                    HTML_MEDIA_TYPE
+                ),
+                (
+                    "first",
+                    "testing.first",
+                    MiddlewarePhase::Fetch,
+                    HTML_MEDIA_TYPE
+                ),
+                ("file", "testing.file", MiddlewarePhase::Fetch, "text/plain"),
+                (
+                    crate::robots_txt::middleware::MODULE,
+                    crate::robots_txt::middleware::MODULE,
+                    MiddlewarePhase::Fetch,
+                    crate::robots_txt::middleware::MEDIA_TYPE
+                ),
+                (
+                    crate::service_version::MODULE,
+                    crate::service_version::MODULE,
+                    MiddlewarePhase::Serve,
+                    HTML_MEDIA_TYPE
+                ),
+            ],
+            "should list what the plan registers first, then core's own, then the linked \
+             builders in order, then core's file and version middleware"
+        );
+    }
+
+    /// Core's robots.txt row names the middleware the registry makes for a
+    /// `[robots-txt]` section, in the phase and for the media type the row
+    /// gives.
+    #[test]
+    fn core_s_robots_txt_row_is_what_the_registry_registers_for_the_section() {
+        use crate::robots_txt::middleware as robots_txt;
+
+        let settings = crate::html_processor::test_support::page_settings(
+            "[robots-txt]
+modules = \"refuse_all\"
+
+[[fetch]]
+media_type = \"text/plain\"
+path = \"/robots.txt\"
+middleware = [\"robots_txt\"]
+",
+        );
+        let registry = IntegrationRegistry::with_registrations(&settings, &[])
+            .expect("should build a registry with the section");
+        let (_, row) = supplied_middleware(&[])
+            .into_iter()
+            .find(|(integration, _)| *integration == robots_txt::MODULE)
+            .expect("the list should carry core's robots.txt row");
+
+        assert!(
+            registry
+                .middleware_in(row.phase)
+                .contains(&robots_txt::MODULE),
+            "the section should register the middleware for the listed phase"
+        );
+        assert_eq!(row.media_type, robots_txt::MEDIA_TYPE);
+    }
+}
diff --git a/crates/trusted-server-core/src/integrations/registry.rs b/crates/trusted-server-core/src/integrations/registry.rs
index efad79e409..76fb6f80f3 100644
--- a/crates/trusted-server-core/src/integrations/registry.rs
+++ b/crates/trusted-server-core/src/integrations/registry.rs
@@ -1528,6 +1528,52 @@ pub struct ProxyDispatchInput<'a> {
 /// # Errors
 ///
 /// Naming the module or the entry at fault.
+/// Refuses a registration that supplies a middleware its builder describes
+/// in a phase the middleware does not run in, or for a media type it does
+/// not work on, so a configuration written from the description runs. A
+/// described middleware the registration leaves out is allowed, because a
+/// module may supply one only where its settings call for it.
+fn check_described_middleware(
+    builder: &crate::integrations::IntegrationBuilder,
+    registration: &IntegrationRegistration,
+) -> Result<(), Report<TrustedServerError>> {
+    let refuse = |message: String| Report::new(TrustedServerError::Configuration { message });
+    for described in builder.middleware() {
+        let Some(middleware) = registration
+            .middleware
+            .iter()
+            .find(|middleware| middleware.middleware_id() == described.name)
+        else {
+            continue;
+        };
+        if !middleware.phases().contains(&described.phase) {
+            let phases: Vec<String> = middleware
+                .phases()
+                .iter()
+                .map(|phase| format!("[[{phase}]]"))
+                .collect();
+            return Err(refuse(format!(
+                "module `{}` describes its middleware `{}` as named in a [[{}]] entry, and the \
+                 middleware it supplies runs in {}",
+                builder.id(),
+                described.name,
+                described.phase,
+                phases.join(" and ")
+            )));
+        }
+        if !middleware.handles_media_type(described.media_type) {
+            return Err(refuse(format!(
+                "module `{}` describes its middleware `{}` as working on `{}`, and the \
+                 middleware it supplies does not",
+                builder.id(),
+                described.name,
+                described.media_type
+            )));
+        }
+    }
+    Ok(())
+}
+
 fn check_middleware(
     settings: &Settings,
     inner: &IntegrationRegistryInner,
@@ -2068,6 +2114,7 @@ impl IntegrationRegistry {
                     builder.id(),
                     "integration builder ID should match registration ID"
                 );
+                check_described_middleware(&builder, &registration)?;
                 plan_registrations.push(registration);
             }
 
@@ -2110,6 +2157,7 @@ impl IntegrationRegistry {
                     builder.id(),
                     "integration builder ID should match registration ID"
                 );
+                check_described_middleware(&builder, &registration)?;
                 registrations.push(registration);
             }
         }
@@ -7927,6 +7975,77 @@ mod tests {
         }
     }
 
+    /// A builder's description of its middleware is checked against what it
+    /// registers, so a configuration written from the description runs.
+    #[test]
+    fn a_description_the_registration_contradicts_is_refused() {
+        use crate::integrations::{IntegrationBuilder, SuppliedMiddleware};
+
+        const NAME: &str = "testing.described";
+        struct FetchOnly;
+        impl Middleware for FetchOnly {
+            fn middleware_id(&self) -> &'static str {
+                NAME
+            }
+            fn phases(&self) -> &[MiddlewarePhase] {
+                &[MiddlewarePhase::Fetch]
+            }
+            fn create(&self, _context: &MiddlewareContext<'_>) -> MiddlewareAction {
+                MiddlewareAction::pass()
+            }
+        }
+        fn register(
+            _settings: &Settings,
+        ) -> Result<Option<IntegrationRegistration>, Report<TrustedServerError>> {
+            Ok(Some(
+                IntegrationRegistration::builder("described")
+                    .with_middleware(Arc::new(FetchOnly))
+                    .build(),
+            ))
+        }
+        const WRONG_PHASE: &[SuppliedMiddleware] =
+            &[SuppliedMiddleware::on_html(NAME, MiddlewarePhase::Serve)];
+        const WRONG_MEDIA_TYPE: &[SuppliedMiddleware] = &[SuppliedMiddleware::on(
+            NAME,
+            MiddlewarePhase::Fetch,
+            "text/plain",
+        )];
+        const RIGHT: &[SuppliedMiddleware] =
+            &[SuppliedMiddleware::on_html(NAME, MiddlewarePhase::Fetch)];
+        let builder = |described| {
+            IntegrationBuilder::new("described", "described-crate", register, validate_nothing)
+                .with_module_name(NAME)
+                .with_middleware(described)
+        };
+        let mut settings = crate::test_support::tests::create_test_settings();
+        settings.select_module("testing", NAME);
+
+        for (described, expected) in [
+            (
+                WRONG_PHASE,
+                "module `described` describes its middleware `testing.described` as named in a \
+                 [[serve]] entry, and the middleware it supplies runs in [[fetch]]",
+            ),
+            (
+                WRONG_MEDIA_TYPE,
+                "module `described` describes its middleware `testing.described` as working on \
+                 `text/plain`, and the middleware it supplies does not",
+            ),
+        ] {
+            let error = IntegrationRegistry::with_registrations(&settings, &[builder(described)])
+                .err()
+                .expect("should refuse a description the registration contradicts");
+
+            let message = error.to_string();
+            assert!(
+                message.contains(expected),
+                "should name the module, the middleware and the difference: {message}"
+            );
+        }
+        IntegrationRegistry::with_registrations(&settings, &[builder(RIGHT)])
+            .expect("should accept a description the registration bears out");
+    }
+
     #[test]
     fn a_module_no_section_selects_supplies_no_middleware() {
         let settings = crate::test_support::tests::create_test_settings();
diff --git a/crates/trusted-server-core/src/provider_table.rs b/crates/trusted-server-core/src/provider_table.rs
index b8222a319e..b73e9a39a8 100644
--- a/crates/trusted-server-core/src/provider_table.rs
+++ b/crates/trusted-server-core/src/provider_table.rs
@@ -17,7 +17,7 @@
 //! its module path, which lets several providers share one implementation
 //! under names of their own. Without the line the table's name stands for
 //! the implementation, which only a section named by the implementation's
-//! type can match, as `mock` in `[ad-server]` is `ad-server.mock`. A provider
+//! type can match, as `iabtl` in `[ad-server]` is `ad-server.iabtl`. A provider
 //! with nothing to set needs no table. [`ProviderTable::validate`] checks the
 //! rules that hold for every type, and the code that reads a type checks what
 //! only that type knows, such as which implementations exist.
diff --git a/crates/trusted-server-core/src/test_support.rs b/crates/trusted-server-core/src/test_support.rs
index 3989a8a62e..b69197afc3 100644
--- a/crates/trusted-server-core/src/test_support.rs
+++ b/crates/trusted-server-core/src/test_support.rs
@@ -478,6 +478,62 @@ pub mod template {
     }
 }
 
+/// Checks a module's description of its middleware against what it
+/// registers.
+#[cfg(any(test, feature = "test-utils"))]
+pub mod middleware {
+    use crate::integrations::{IntegrationBuilder, IntegrationRegistry, supplied_middleware};
+    use crate::settings::Settings;
+
+    /// Asserts that the builder with the integration id `id`, among the
+    /// built-in builders and `builders`, describes exactly the middleware its
+    /// registration supplies under `settings`, in the order the registration
+    /// supplies them, and that each runs in the phase it is described in.
+    ///
+    /// # Panics
+    ///
+    /// When the registry cannot be built, which includes a description the
+    /// registration contradicts, when `id` does not run under `settings`, or
+    /// when the description and the registration differ.
+    pub fn assert_described_middleware_is_registered(
+        settings: &Settings,
+        builders: &[IntegrationBuilder],
+        id: &str,
+    ) {
+        let registry = IntegrationRegistry::with_registrations(settings, builders)
+            .expect("should build a registry whose descriptions match what it registers");
+        let registered = registry
+            .registered_integrations()
+            .into_iter()
+            .find(|integration| integration.id == id)
+            .map(|integration| integration.middleware)
+            .expect("the described module should run under the settings");
+        let described: Vec<&str> = supplied_middleware(builders)
+            .into_iter()
+            .filter(|(integration, _)| *integration == id)
+            .map(|(_, middleware)| middleware.name)
+            .collect();
+
+        assert_eq!(
+            described, registered,
+            "`{id}` should describe the middleware it registers, in registration order"
+        );
+        for (_, middleware) in supplied_middleware(builders)
+            .into_iter()
+            .filter(|(integration, _)| *integration == id)
+        {
+            assert!(
+                registry
+                    .middleware_in(middleware.phase)
+                    .contains(&middleware.name),
+                "`{}` should run in [[{}]] as described",
+                middleware.name,
+                middleware.phase
+            );
+        }
+    }
+}
+
 /// Shared Next.js + auction origin fixture.
 ///
 /// Adapters exercise the buffered publisher path against this fixture in their
diff --git a/crates/trusted-server-integration-tests/Cargo.toml b/crates/trusted-server-integration-tests/Cargo.toml
index 0251a4bb85..a2b972efaa 100644
--- a/crates/trusted-server-integration-tests/Cargo.toml
+++ b/crates/trusted-server-integration-tests/Cargo.toml
@@ -26,8 +26,10 @@ hex = { workspace = true }
 serde_json = { workspace = true }
 sha2 = { workspace = true }
 toml = { workspace = true }
+# The fixture configurations are validated against the modules the Axum
+# adapter links, which are the modules every adapter links.
+trusted-server-adapter-axum = { path = "../trusted-server-adapter-axum" }
 trusted-server-core = { workspace = true, features = ["test-utils"] }
-trusted-server-modules = { workspace = true }
 
 [dev-dependencies]
 async-trait = { workspace = true }
@@ -46,7 +48,6 @@ scraper = { workspace = true }
 testcontainers = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread"] }
 tower = { workspace = true, features = ["util"] }
-trusted-server-adapter-axum = { path = "../trusted-server-adapter-axum" }
 trusted-server-adapter-cloudflare = { path = "../trusted-server-adapter-cloudflare" }
 trusted-server-adapter-spin = { path = "../trusted-server-adapter-spin" }
 urlencoding = { workspace = true }
diff --git a/crates/trusted-server-integration-tests/src/bin/generate-viceroy-config.rs b/crates/trusted-server-integration-tests/src/bin/generate-viceroy-config.rs
index aba8e419e5..1a2bb17443 100644
--- a/crates/trusted-server-integration-tests/src/bin/generate-viceroy-config.rs
+++ b/crates/trusted-server-integration-tests/src/bin/generate-viceroy-config.rs
@@ -177,9 +177,11 @@ fn build_app_config_envelope(
         origin.url = origin_url.to_string();
         settings.set_origin_source(&origin);
     }
-    // The fixture selects modules a stock build ships, so validation needs
-    // the stock list as the adapters and the `ts` tool have it.
-    trusted_server_core::config::register_deploy_integrations(trusted_server_modules::builders());
+    // The fixture selects modules the adapters link, so validation needs the
+    // list as the adapters and the `ts` tool have it.
+    trusted_server_core::config::register_deploy_integrations(
+        trusted_server_adapter_axum::app::shipped_module_builders(),
+    );
     let app_config = TrustedServerAppConfig::new(settings)
         .map_err(|report| error_box(format!("invalid Trusted Server app config: {report:?}")))?;
 
@@ -511,7 +513,7 @@ mod tests {
             CONFIG_BLOB_KEY,
             &StoreName::from("trusted_server_secrets"),
             PolicyOrigin::Blob,
-            &trusted_server_modules::builders(),
+            &trusted_server_adapter_axum::app::shipped_module_builders(),
         )
         .expect("should load the settings through the chunk pointer");
 
@@ -541,7 +543,7 @@ mod tests {
             &integration_secret_store(),
             &StoreName::from("trusted_server_secrets"),
             PolicyOrigin::Blob,
-            &trusted_server_modules::builders(),
+            &trusted_server_adapter_axum::app::shipped_module_builders(),
         )
         .expect("should verify blob");
 
diff --git a/crates/trusted-server-integration-tests/tests/common/config.rs b/crates/trusted-server-integration-tests/tests/common/config.rs
index b4b0139268..bf7cc5f954 100644
--- a/crates/trusted-server-integration-tests/tests/common/config.rs
+++ b/crates/trusted-server-integration-tests/tests/common/config.rs
@@ -56,9 +56,11 @@ fn app_config_envelope(
     })?;
     origin.url = origin_url;
     settings.set_origin_source(&origin);
-    // The fixture selects modules a stock build ships, so validation needs
-    // the stock list as the adapters and the `ts` tool have it.
-    trusted_server_core::config::register_deploy_integrations(trusted_server_modules::builders());
+    // The fixture selects modules the adapters link, so validation needs the
+    // list as the adapters and the `ts` tool have it.
+    trusted_server_core::config::register_deploy_integrations(
+        trusted_server_adapter_axum::app::shipped_module_builders(),
+    );
     // What `ts config push --permissions` writes for the sample the fixture
     // names. Axum reads the file from its folder and leaves the text unused.
     settings.permissions.sha256 = Some(policy_sha256(SAMPLE_POLICY_TEXT));
diff --git a/crates/trusted-server-modules/Cargo.toml b/crates/trusted-server-modules/Cargo.toml
deleted file mode 100644
index 0474c7f13a..0000000000
--- a/crates/trusted-server-modules/Cargo.toml
+++ /dev/null
@@ -1,50 +0,0 @@
-[package]
-name = "trusted-server-modules"
-description = "The modules a stock build of Trusted Server ships from crates of their own, in the order their hooks run."
-authors = { workspace = true }
-edition = { workspace = true }
-license = { workspace = true }
-publish = { workspace = true }
-version = { workspace = true }
-
-[lib]
-doctest = false
-
-[lints]
-workspace = true
-
-[dependencies]
-trusted-server-ad-server-mock = { workspace = true }
-trusted-server-ad-tag-google = { workspace = true }
-trusted-server-auction-aps = { workspace = true }
-trusted-server-auction-prebid = { workspace = true }
-trusted-server-auction-prebid-server = { workspace = true }
-trusted-server-auction-protocol-openrtb = { workspace = true }
-trusted-server-audience-permutive = { workspace = true }
-trusted-server-bot-protection-datadome = { workspace = true }
-trusted-server-cmp-didomi = { workspace = true }
-trusted-server-cmp-inmobi = { workspace = true }
-trusted-server-ads-txt-sellers = { workspace = true }
-trusted-server-cmp-osano = { workspace = true }
-trusted-server-cmp-sourcepoint = { workspace = true }
-trusted-server-core = { workspace = true }
-trusted-server-framework-nextjs = { workspace = true }
-trusted-server-headers-geo = { workspace = true }
-trusted-server-identity-lockr = { workspace = true }
-trusted-server-tag-google-tag = { workspace = true }
-trusted-server-tag-google-tag-manager = { workspace = true }
-trusted-server-testing-testlight = { workspace = true }
-
-[dev-dependencies]
-edgezero-core = { workspace = true }
-http = { workspace = true }
-serde_json = { workspace = true }
-tokio = { workspace = true }
-trusted-server-core = { workspace = true, features = ["test-utils"] }
-
-# The visible owner of this crate, the way Prebid.js requires a named
-# maintainer of every adapter. Which modules a stock build ships is the
-# project's own decision, so the Trusted Server maintainers own it.
-[package.metadata.maintainers]
-owner = "Trusted Server maintainers"
-status = "project owned"
diff --git a/crates/trusted-server-modules/src/lib.rs b/crates/trusted-server-modules/src/lib.rs
deleted file mode 100644
index 4c17d0af70..0000000000
--- a/crates/trusted-server-modules/src/lib.rs
+++ /dev/null
@@ -1,984 +0,0 @@
-//! The modules a stock build of Trusted Server ships from crates of their own.
-//!
-//! Every adapter and the `ts` command line tool take this list, so one place
-//! says which of those modules a stock build offers and in what order their
-//! hooks run. Offering a module does not run it, because the registry builds a
-//! module only when a section of the settings selects it.
-//!
-//! It also says which middleware those modules supply, so a tool that writes
-//! a configuration can place a module's page changes without naming one
-//! itself.
-//!
-//! A deployment that ships a module of its own hands that module's builder to
-//! its adapter, which runs it after these.
-
-#![cfg_attr(
-    test,
-    allow(clippy::panic, reason = "tests use panic-on-failure helpers")
-)]
-
-use trusted_server_core::integrations::IntegrationBuilder;
-use trusted_server_core::middleware::{HTML_MEDIA_TYPE, MiddlewarePhase};
-
-/// The builders of the modules a stock build ships from crates of their own,
-/// in hook order. None offers a loading cache, so a deployment that wants
-/// copies kept hands a loading cache module's builder to its adapter.
-#[must_use]
-pub fn builders() -> Vec<IntegrationBuilder> {
-    vec![
-        // Prebid registers from the auction plan, and what it registers runs
-        // ahead of the modules below.
-        trusted_server_auction_prebid::builder(),
-        trusted_server_testing_testlight::builder(),
-        trusted_server_framework_nextjs::builder(),
-        trusted_server_audience_permutive::builder(),
-        trusted_server_identity_lockr::builder(),
-        trusted_server_cmp_didomi::builder(),
-        trusted_server_cmp_inmobi::builder(),
-        trusted_server_cmp_sourcepoint::builder(),
-        trusted_server_cmp_osano::builder(),
-        trusted_server_tag_google_tag::builder(),
-        trusted_server_tag_google_tag_manager::builder(),
-        trusted_server_bot_protection_datadome::builder(),
-        trusted_server_ad_tag_google::builder(),
-        trusted_server_ad_tag_google::diagnostics::builder(),
-        trusted_server_ads_txt_sellers::builder(),
-        trusted_server_headers_geo::builder(),
-        // Implementations `[demand]` and `[ad-server]` can name, which no
-        // section selects.
-        trusted_server_auction_protocol_openrtb::builder(),
-        trusted_server_auction_prebid_server::builder(),
-        trusted_server_auction_aps::builder(),
-        trusted_server_ad_server_mock::builder(),
-    ]
-}
-
-/// The stock builders followed by `extra`, the builders a deployment added,
-/// which is the order their hooks run in.
-#[must_use]
-pub fn builders_with(extra: &[IntegrationBuilder]) -> Vec<IntegrationBuilder> {
-    let mut all = builders();
-    all.extend_from_slice(extra);
-    all
-}
-
-/// The section that selects the stock module with the integration id `id`,
-/// and the name the module is written under there.
-///
-/// A tool that knows an integration by its id, as the `ts` audit does from
-/// what it finds on a page, writes a configuration with this and names no
-/// module itself.
-#[must_use]
-pub fn selection_of(id: &str) -> Option<(&'static str, &'static str)> {
-    let builder = builders().into_iter().find(|builder| builder.id() == id)?;
-    let section = builder.section()?;
-    Some((
-        section,
-        trusted_server_core::module_name::short_form(section, builder.module_name()?),
-    ))
-}
-
-/// A middleware a stock module supplies.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct StockMiddleware {
-    /// The id of the integration that supplies it.
-    pub integration: &'static str,
-    /// The phase it runs in.
-    pub phase: MiddlewarePhase,
-    /// The media type it works on, which an entry naming it covers.
-    pub media_type: &'static str,
-    /// The name an entry writes.
-    pub name: &'static str,
-}
-
-/// The middleware a stock build's modules supply, core's script proxy among
-/// them and core's service version last, in the order a deployment that
-/// runs them all names them in an entry.
-///
-/// That is the order the registry registers the modules in. Prebid registers
-/// from the auction plan and so comes first, core's script proxy is the first
-/// module a section selects, and the rest follow [`builders`].
-#[must_use]
-pub fn middleware() -> Vec<StockMiddleware> {
-    use MiddlewarePhase::{Fetch, Serve};
-    use trusted_server_ad_tag_google as google;
-    use trusted_server_ads_txt_sellers as ads_txt_sellers;
-    use trusted_server_auction_prebid as prebid;
-    use trusted_server_audience_permutive as permutive;
-    use trusted_server_bot_protection_datadome as datadome;
-    use trusted_server_cmp_didomi as didomi;
-    use trusted_server_cmp_inmobi as inmobi;
-    use trusted_server_cmp_sourcepoint as sourcepoint;
-    use trusted_server_core::integrations::js_asset_proxy;
-    use trusted_server_core::robots_txt::middleware as robots_txt;
-    use trusted_server_core::service_version;
-    use trusted_server_framework_nextjs as nextjs;
-    use trusted_server_headers_geo as geo_headers;
-    use trusted_server_identity_lockr as lockr;
-    use trusted_server_tag_google_tag as google_tag;
-    use trusted_server_tag_google_tag_manager as google_tag_manager;
-    use trusted_server_testing_testlight as testlight;
-
-    let row = |integration, phase, name| StockMiddleware {
-        integration,
-        phase,
-        media_type: HTML_MEDIA_TYPE,
-        name,
-    };
-    vec![
-        row(prebid::builder().id(), Fetch, prebid::MODULE),
-        // Core registers its script proxy under the module's own name.
-        row(js_asset_proxy::MODULE, Fetch, js_asset_proxy::MODULE),
-        row(testlight::builder().id(), Fetch, testlight::MODULE),
-        row(nextjs::builder().id(), Fetch, nextjs::MODULE),
-        StockMiddleware {
-            integration: nextjs::builder().id(),
-            phase: Fetch,
-            media_type: nextjs::FLIGHT_MEDIA_TYPE,
-            name: nextjs::FLIGHT_MIDDLEWARE,
-        },
-        row(permutive::builder().id(), Fetch, permutive::MODULE),
-        row(lockr::builder().id(), Fetch, lockr::MODULE),
-        row(didomi::builder().id(), Fetch, didomi::MODULE),
-        row(inmobi::builder().id(), Fetch, inmobi::MODULE),
-        row(sourcepoint::builder().id(), Fetch, sourcepoint::MODULE),
-        row(google_tag::builder().id(), Serve, google_tag::MODULE),
-        row(
-            google_tag_manager::builder().id(),
-            Fetch,
-            google_tag_manager::MODULE,
-        ),
-        row(datadome::builder().id(), Fetch, datadome::MODULE),
-        row(datadome::builder().id(), Serve, datadome::TAG_MIDDLEWARE),
-        row(google::builder().id(), Fetch, google::MODULE),
-        row(google::builder().id(), Serve, google::LOADER_MIDDLEWARE),
-        row(
-            google::diagnostics::builder().id(),
-            Serve,
-            google::diagnostics::MODULE,
-        ),
-        StockMiddleware {
-            integration: ads_txt_sellers::builder().id(),
-            phase: Fetch,
-            media_type: ads_txt_sellers::MEDIA_TYPE,
-            name: ads_txt_sellers::MODULE,
-        },
-        row(geo_headers::builder().id(), Serve, geo_headers::MODULE),
-        // Core makes the file `[robots-txt]` describes under the module's
-        // own name, on the file's path alone.
-        StockMiddleware {
-            integration: robots_txt::MODULE,
-            phase: Fetch,
-            media_type: robots_txt::MEDIA_TYPE,
-            name: robots_txt::MODULE,
-        },
-        // Core writes the platform's service version where a serve entry
-        // names it.
-        row(service_version::MODULE, Serve, service_version::MODULE),
-    ]
-}
-
-/// The names of the page middleware that the stock modules with the
-/// integration ids `ids` supply for `phase`, in the order an entry names
-/// them. A middleware for a media type other than HTML is left out, because
-/// the entry a tool writes covers every page.
-///
-/// A tool that knows a module by its integration id, as the `ts` audit does
-/// from what it finds on a page, writes the entry that places the module's
-/// page changes with this and names no middleware itself.
-#[must_use]
-pub fn middleware_for(ids: &[&str], phase: MiddlewarePhase) -> Vec<&'static str> {
-    middleware()
-        .into_iter()
-        .filter(|row| {
-            row.phase == phase
-                && row.media_type == HTML_MEDIA_TYPE
-                && ids.contains(&row.integration)
-        })
-        .map(|row| row.name)
-        .collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use trusted_server_core::integrations::{IntegrationBuilder, IntegrationRegistry};
-    use trusted_server_core::middleware::{HTML_MEDIA_TYPE, MiddlewarePhase};
-
-    use super::{builders, builders_with, middleware, middleware_for, selection_of};
-
-    /// The settings each stock module's recorded page is made with, which
-    /// select the module and place every middleware it supplies.
-    const PAGE_SETTINGS: &[&str] = &[
-        include_str!("../../auction/prebid/src/fixtures/page-change.settings.toml"),
-        include_str!(
-            "../../trusted-server-core/src/integrations/fixtures/js-asset-proxy.settings.toml"
-        ),
-        include_str!("../../testing/testlight/src/fixtures/page-change.settings.toml"),
-        include_str!("../../framework/nextjs/src/fixtures/page-change.settings.toml"),
-        include_str!("../../audience/permutive/src/fixtures/page-change.settings.toml"),
-        include_str!("../../identity/lockr/src/fixtures/page-change.settings.toml"),
-        include_str!("../../cmp/didomi/src/fixtures/page-change.settings.toml"),
-        include_str!("../../cmp/inmobi/src/fixtures/page-change.settings.toml"),
-        include_str!("../../cmp/sourcepoint/src/fixtures/page-change.settings.toml"),
-        include_str!("../../tag/google-tag/src/fixtures/page-change.settings.toml"),
-        include_str!("../../tag/google-tag-manager/src/fixtures/page-change.settings.toml"),
-        include_str!("../../bot-protection/datadome/src/fixtures/page-change.settings.toml"),
-        include_str!("../../ad-tag/google/src/fixtures/page-change.settings.toml"),
-        include_str!("../../ads-txt/sellers/src/fixtures/sellers.settings.toml"),
-        include_str!("../../headers/geo/src/fixtures/geo-headers.settings.toml"),
-    ];
-
-    #[test]
-    fn the_listed_middleware_are_the_ones_the_modules_register() {
-        let listed = middleware();
-        let mut checked: Vec<&str> = Vec::new();
-
-        for module_settings in PAGE_SETTINGS {
-            let settings =
-                trusted_server_core::html_processor::test_support::page_settings(module_settings);
-            let registry = IntegrationRegistry::with_registrations(&settings, &builders())
-                .expect("should build a registry from a recorded page's settings");
-            let running: Vec<&str> = registry
-                .registered_integrations()
-                .iter()
-                .map(|integration| integration.id)
-                .collect();
-
-            // A middleware that runs in several phases is listed in the one a
-            // tool writes it in, so what is listed for a phase is registered
-            // for it, and everything registered is listed somewhere.
-            let listed_anywhere: Vec<&str> = listed
-                .iter()
-                .filter(|row| running.contains(&row.integration))
-                .map(|row| row.name)
-                .collect();
-            for phase in MiddlewarePhase::ALL {
-                let registered = registry.middleware_in(phase);
-                for row in listed
-                    .iter()
-                    .filter(|row| row.phase == phase && running.contains(&row.integration))
-                {
-                    assert!(
-                        registered.contains(&row.name),
-                        "{} is listed for {phase} and the modules {running:?} do not register it \
-                         for that phase: {registered:?}",
-                        row.name
-                    );
-                }
-                for name in &registered {
-                    assert!(
-                        listed_anywhere.contains(name),
-                        "{name} is registered for {phase} by the modules {running:?} and listed \
-                         in no phase"
-                    );
-                }
-            }
-            checked.extend(running);
-        }
-
-        checked.push(trusted_server_core::robots_txt::middleware::MODULE);
-        for row in &listed {
-            assert!(
-                checked.contains(&row.integration),
-                "should check `{}` against a module that registers it, and none of the \
-                 recorded pages runs `{}`",
-                row.name,
-                row.integration
-            );
-        }
-    }
-
-    /// The row for core's robots.txt middleware is registered by settings
-    /// that carry the section and the entry, in the phase the row lists.
-    #[test]
-    fn core_s_robots_txt_middleware_is_registered_with_the_section() {
-        use trusted_server_core::robots_txt::middleware as robots_txt;
-
-        let settings = trusted_server_core::html_processor::test_support::page_settings(
-            "[robots-txt]
-modules = \"refuse_all\"
-
-[[fetch]]
-media_type = \"text/plain\"
-path = \"/robots.txt\"
-middleware = [\"robots_txt\"]
-",
-        );
-        let registry = IntegrationRegistry::with_registrations(&settings, &builders())
-            .expect("should build a registry with the section");
-        let row = middleware()
-            .into_iter()
-            .find(|row| row.name == robots_txt::MODULE)
-            .expect("the stock list should carry the row");
-
-        assert!(
-            registry
-                .middleware_in(row.phase)
-                .contains(&robots_txt::MODULE),
-            "the section should register the middleware for the listed phase"
-        );
-        assert_eq!(row.media_type, robots_txt::MEDIA_TYPE);
-    }
-
-    #[test]
-    fn the_listed_middleware_follow_the_order_the_modules_register_in() {
-        // What registers from the auction plan goes first, core's own module
-        // is the first a section selects, and the stock modules follow.
-        let mut order = vec![
-            trusted_server_auction_prebid::builder().id(),
-            trusted_server_core::integrations::js_asset_proxy::MODULE,
-        ];
-        for builder in builders() {
-            if !order.contains(&builder.id()) {
-                order.push(builder.id());
-            }
-        }
-        // Core makes the file's middleware once every registration is in,
-        // so it comes after every module's.
-        order.push(trusted_server_core::robots_txt::middleware::MODULE);
-        // Core's own middleware is registered after every module's.
-        order.push(trusted_server_core::service_version::MODULE);
-        let place = |integration: &str| {
-            order
-                .iter()
-                .position(|id| *id == integration)
-                .unwrap_or_else(|| panic!("`{integration}` should be a stock module"))
-        };
-
-        for phase in MiddlewarePhase::ALL {
-            let places: Vec<usize> = middleware()
-                .iter()
-                .filter(|row| row.phase == phase)
-                .map(|row| place(row.integration))
-                .collect();
-            assert!(
-                places.is_sorted(),
-                "should list the {phase} middleware in the order their modules register: \
-                 {places:?}"
-            );
-        }
-    }
-
-    #[test]
-    fn the_template_s_entries_name_the_listed_middleware() {
-        use trusted_server_core::settings::Settings;
-        use trusted_server_core::test_support::template::{
-            template_with_resolved_required_secrets, uncomment_block,
-        };
-
-        let template = uncomment_block(
-            &uncomment_block(&template_with_resolved_required_secrets(), "[[fetch]]"),
-            "[[serve]]",
-        );
-        let settings =
-            Settings::from_toml(&template).expect("should load the template with its entries");
-
-        for phase in MiddlewarePhase::ALL {
-            let entries = settings.phase_entries(phase).entries();
-            let mut media_types: Vec<&str> = Vec::new();
-            for row in middleware().iter().filter(|row| row.phase == phase) {
-                if !media_types.contains(&row.media_type) {
-                    media_types.push(row.media_type);
-                }
-            }
-            for media_type in media_types {
-                let listed: Vec<&str> = middleware()
-                    .iter()
-                    .filter(|row| row.phase == phase && row.media_type == media_type)
-                    .map(|row| row.name)
-                    .collect();
-                let covering: Vec<_> = entries
-                    .iter()
-                    .filter(|entry| entry.media_type == media_type)
-                    .collect();
-                if media_type == HTML_MEDIA_TYPE
-                    || covering.iter().any(|entry| entry.path.is_none())
-                {
-                    // One entry covers every page, for HTML and for a media
-                    // type a page's own responses come in.
-                    assert_eq!(
-                        covering.len(),
-                        1,
-                        "should document one [[{phase}]] entry for {media_type}"
-                    );
-                    assert!(
-                        covering[0].path.is_none(),
-                        "should document the [[{phase}]] entry that covers every page"
-                    );
-                } else {
-                    // A file's middleware is placed on the file's own path, one
-                    // entry for each file.
-                    assert!(
-                        !covering.is_empty(),
-                        "should document a [[{phase}]] entry on a path for each {media_type} file"
-                    );
-                }
-                let named: Vec<&str> = covering
-                    .iter()
-                    .flat_map(|entry| entry.middleware.iter().map(String::as_str))
-                    .collect();
-                assert_eq!(
-                    named, listed,
-                    "should document every {phase} middleware the stock modules supply for \
-                     {media_type}, in the listed order"
-                );
-            }
-        }
-    }
-
-    #[test]
-    fn the_guide_s_table_lists_the_same_middleware() {
-        const GUIDE: &str = include_str!(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/../../docs/guide/configuration.md"
-        ));
-
-        // A row of the table is a name and then the list it is written in.
-        let documented: Vec<(String, String)> = GUIDE
-            .lines()
-            .filter_map(|line| {
-                let mut cells = line.split('|').map(str::trim).skip(1);
-                let name = cells.next()?.strip_prefix('`')?.strip_suffix('`')?;
-                let list = cells.next()?.strip_prefix("`[[")?.strip_suffix("]]`")?;
-                Some((name.to_owned(), list.to_owned()))
-            })
-            .collect();
-        let listed: Vec<(String, String)> = middleware()
-            .iter()
-            .map(|row| (row.name.to_owned(), row.phase.to_string()))
-            .collect();
-
-        assert_eq!(
-            documented, listed,
-            "should document the middleware the stock modules supply, each with its phase, \
-             in the listed order"
-        );
-    }
-
-    #[test]
-    fn a_tool_is_handed_a_module_s_middleware_by_its_integration_id() {
-        use trusted_server_bot_protection_datadome as datadome;
-        use trusted_server_cmp_didomi as didomi;
-
-        let ids = [datadome::builder().id(), didomi::builder().id()];
-
-        assert_eq!(
-            middleware_for(&ids, MiddlewarePhase::Fetch),
-            [didomi::MODULE, datadome::MODULE],
-            "should name the modules' fetch middleware in the order an entry runs them, \
-             whatever order the ids came in"
-        );
-        assert_eq!(
-            middleware_for(&ids, MiddlewarePhase::Serve),
-            [datadome::TAG_MIDDLEWARE],
-            "should name the one serve middleware the two supply"
-        );
-        assert!(
-            middleware_for(&["no_such_module"], MiddlewarePhase::Fetch).is_empty(),
-            "should name nothing for an id no stock module has"
-        );
-    }
-
-    #[test]
-    fn stock_modules_are_offered_in_hook_order() {
-        // A module is named by what its section selects, and an
-        // implementation by what `[demand]` or `[ad-server]` names.
-        let names: Vec<&str> = builders()
-            .iter()
-            .map(|builder| {
-                builder
-                    .module_name()
-                    .or_else(|| builder.demand().map(|demand| demand.id))
-                    .or_else(|| builder.adserver().map(|adserver| adserver.id))
-                    .unwrap_or_else(|| builder.id())
-            })
-            .collect();
-
-        assert_eq!(
-            names,
-            [
-                "auction.prebid",
-                "testing.testlight",
-                "framework.nextjs",
-                "audience.permutive",
-                "identity.lockr",
-                "cmp.didomi",
-                "cmp.inmobi",
-                "cmp.sourcepoint",
-                "cmp.osano",
-                "tag.google-tag",
-                "tag.google-tag-manager",
-                "bot-protection.datadome",
-                "ad-tag.google",
-                "ad-tag.google.diagnostics",
-                "ads-txt.sellers",
-                "headers.geo",
-                "auction-protocol.openrtb",
-                "auction.prebid-server",
-                "auction.aps",
-                "ad-server.mock",
-            ],
-            "should offer the stock modules in the order their hooks run"
-        );
-    }
-
-    /// A stock build links no loading cache module, so every feature loads
-    /// through `NoLoadingCache`, which keeps no copy, and a deployment that
-    /// wants copies kept hands a loading cache module's builder to its
-    /// adapter.
-    #[test]
-    fn the_stock_build_links_no_loading_cache() {
-        let offering: Vec<&str> = builders()
-            .iter()
-            .filter(|builder| builder.loading_cache().is_some())
-            .map(IntegrationBuilder::id)
-            .collect();
-
-        assert!(
-            offering.is_empty(),
-            "a stock build should link no loading cache, and links {offering:?}"
-        );
-    }
-
-    #[test]
-    fn a_deployment_s_builders_follow_the_stock_ones() {
-        let stock = builders().len();
-        let extra = [trusted_server_cmp_osano::builder()];
-
-        let all = builders_with(&extra);
-
-        assert_eq!(
-            all.len(),
-            stock + 1,
-            "should keep every stock builder and add the deployment's"
-        );
-        assert_eq!(
-            all.last().map(IntegrationBuilder::source),
-            Some("trusted-server-cmp-osano"),
-            "should put the deployment's builder last"
-        );
-    }
-
-    /// The `ts` tool registers the stock builders, so validating a deployment's
-    /// settings before a push runs each stock module's own rules.
-    #[test]
-    fn deploy_validation_runs_a_stock_module_s_own_rules() {
-        use serde_json::json;
-        use trusted_server_core::config::{TrustedServerAppConfig, register_deploy_integrations};
-        use trusted_server_core::test_support::tests::create_test_settings;
-
-        register_deploy_integrations(builders());
-
-        TrustedServerAppConfig::new(create_test_settings())
-            .expect("should accept the settings before a module's table is wrong");
-
-        let mut settings = create_test_settings();
-        settings
-            .insert_module_config(
-                "cmp",
-                trusted_server_cmp_osano::MODULE,
-                &json!({ "typo": true }),
-            )
-            .expect("should insert the module's table");
-
-        let error = TrustedServerAppConfig::new(settings)
-            .expect_err("should refuse a table the stock module's own rules reject");
-
-        let rendered = format!("{error:?}");
-        assert!(
-            rendered.contains("[cmp.osano]"),
-            "should name the module's table: {rendered}"
-        );
-    }
-
-    /// Every documented table should be push-ready, so uncommenting its
-    /// section's selection and the table with the shown values must parse and
-    /// pass field validation. Tables that ship a deliberately invalid
-    /// placeholder that is not a secret (the Google Tag Manager
-    /// `container_id`) are left out.
-    #[test]
-    fn documented_module_tables_validate_when_uncommented_and_selected() {
-        use trusted_server_audience_permutive as permutive;
-        use trusted_server_cmp_sourcepoint as sourcepoint;
-        use trusted_server_core::settings::Settings;
-        use trusted_server_core::test_support::template::{
-            template_with_resolved_required_secrets, uncomment_block,
-        };
-        use trusted_server_identity_lockr as lockr;
-
-        let base = template_with_resolved_required_secrets();
-
-        for (section, selection, header, name) in [
-            (
-                "[audience]",
-                "module = \"permutive\"",
-                "[audience.permutive]",
-                permutive::MODULE,
-            ),
-            (
-                "[identity]",
-                "module = \"lockr\"",
-                "[identity.lockr]",
-                lockr::MODULE,
-            ),
-            (
-                "[cmp]",
-                "module = \"sourcepoint\"",
-                "[cmp.sourcepoint]",
-                sourcepoint::MODULE,
-            ),
-        ] {
-            let toml = format!(
-                "{}\n{section}\n{selection}\n",
-                uncomment_block(&base, header)
-            );
-            let settings = Settings::from_toml(&toml)
-                .unwrap_or_else(|err| panic!("uncommented {header} should parse: {err:?}"));
-
-            let valid = match name {
-                permutive::MODULE => settings
-                    .module_config::<permutive::PermutiveConfig>(name)
-                    .unwrap_or_else(|err| panic!("{header} should validate: {err:?}"))
-                    .is_some(),
-                lockr::MODULE => settings
-                    .module_config::<lockr::LockrConfig>(name)
-                    .unwrap_or_else(|err| panic!("{header} should validate: {err:?}"))
-                    .is_some(),
-                _ => settings
-                    .module_config::<sourcepoint::SourcepointConfig>(name)
-                    .unwrap_or_else(|err| panic!("{header} should validate: {err:?}"))
-                    .is_some(),
-            };
-            assert!(valid, "{header} should resolve to a valid config");
-        }
-    }
-
-    /// Every stock page module refuses a setting it does not know, so a
-    /// misspelt key in its table fails deploy validation naming the table and
-    /// the key, where it would otherwise be ignored.
-    #[test]
-    fn every_stock_module_rejects_a_setting_it_does_not_know() {
-        use serde_json::json;
-        use trusted_server_core::config::validate_settings_for_deploy_with;
-        use trusted_server_core::module_name::short_form;
-        use trusted_server_core::test_support::tests::create_test_settings;
-
-        let stock = builders();
-        for builder in stock
-            .iter()
-            .filter(|builder| builder.supplies_integration())
-        {
-            let name = builder
-                .module_name()
-                .expect("every stock page module names itself");
-            let section = builder
-                .section()
-                .expect("every stock page module has a section");
-            let mut settings = create_test_settings();
-            settings
-                .insert_module_config(section, name, &json!({ "no_such_setting": true }))
-                .expect("should insert the planted table");
-
-            let error = match validate_settings_for_deploy_with(&settings, &stock) {
-                Ok(()) => panic!("`{name}` should refuse a setting it does not know"),
-                Err(error) => format!("{error:?}"),
-            };
-            let written = short_form(section, name);
-            assert!(
-                error.contains(&format!("[{section}.{written}]"))
-                    && error.contains("no_such_setting"),
-                "`{name}` should name its table and the unknown setting: {error}"
-            );
-        }
-    }
-
-    /// The adapters run the registry's request preparers and name no module,
-    /// so this list is what attaches the diagnostics module's preparer. It
-    /// strips the module's reserved query and cookie in a deployment that
-    /// does not select the module, as it does in one that does.
-    #[test]
-    fn the_stock_list_attaches_the_diagnostics_module_s_request_preparer() {
-        use edgezero_core::body::Body as EdgeBody;
-        use http::{Method, Request, header};
-        use trusted_server_core::integrations::IntegrationRegistry;
-        use trusted_server_core::test_support::tests::create_test_settings;
-
-        let settings = create_test_settings();
-        let registry = IntegrationRegistry::with_registrations(&settings, &builders())
-            .expect("should build registry");
-        let mut request = Request::builder()
-            .method(Method::GET)
-            .uri("https://publisher.example.com/article?ts_console=1&keep=yes")
-            .header(header::COOKIE, "__Host-ts-console=1; keep-me=yes")
-            .body(EdgeBody::empty())
-            .expect("should build request");
-
-        registry
-            .prepare_request(&settings, &mut request)
-            .expect("should run the stock preparers");
-
-        assert_eq!(
-            request.uri().query(),
-            Some("keep=yes"),
-            "should strip the reserved diagnostics query and keep the rest"
-        );
-        assert_eq!(
-            request
-                .headers()
-                .get(header::COOKIE)
-                .map(|value| value.to_str().expect("cookie should be text")),
-            Some("keep-me=yes"),
-            "should strip the reserved diagnostics cookie and keep the rest"
-        );
-    }
-
-    #[test]
-    fn a_stock_module_s_selection_is_found_by_its_integration_id() {
-        for (id, section, written) in [
-            ("prebid", "auction", "prebid"),
-            ("datadome", "bot-protection", "datadome"),
-            ("didomi", "cmp", "didomi"),
-            ("sourcepoint", "cmp", "sourcepoint"),
-            ("osano", "cmp", "osano"),
-            ("lockr", "identity", "lockr"),
-            ("permutive", "audience", "permutive"),
-            ("nextjs", "framework", "nextjs"),
-            ("gpt", "ad-tag", "google"),
-            ("google_tag_manager", "tag", "google-tag-manager"),
-            // Testlight says `[auction]` selects it, where its full name is
-            // written.
-            ("testlight", "auction", "testing.testlight"),
-        ] {
-            assert_eq!(
-                selection_of(id),
-                Some((section, written)),
-                "should find where `{id}` is selected"
-            );
-        }
-        assert_eq!(
-            selection_of("no-such-integration"),
-            None,
-            "should find nothing for an id no stock module has"
-        );
-    }
-
-    /// The `ts` tool registers the stock builders, so the secret settings a
-    /// stock module declares are among the leaves a push treats as naming a
-    /// key.
-    #[test]
-    fn a_stock_module_s_secret_settings_are_listed_once_the_list_is_registered() {
-        use edgezero_core::app_config::AppConfigMeta as _;
-        use trusted_server_core::config::{TrustedServerAppConfig, register_deploy_integrations};
-
-        register_deploy_integrations(builders());
-
-        let paths = TrustedServerAppConfig::secret_fields()
-            .iter()
-            .map(edgezero_core::app_config::SecretField::dotted_path)
-            .collect::<Vec<_>>();
-
-        for expected in [
-            "bot-protection.datadome.server_side_key_secret_name",
-            "bot-protection.datadome.protection_test_bypass.credential_secret_name",
-        ] {
-            assert!(
-                paths.iter().any(|path| path == expected),
-                "should list `{expected}` among {paths:?}"
-            );
-        }
-    }
-
-    /// The mock ad server decides between the bids APS returned, and the
-    /// winner keeps the seat the exchange returned, APS's own bidder name and
-    /// its renderer.
-    #[tokio::test]
-    async fn the_mock_ad_server_keeps_an_aps_winner_s_identities_and_renderer() {
-        use std::collections::{BTreeMap, HashMap};
-        use std::sync::Arc;
-
-        use trusted_server_ad_server_mock::{AdServerMockProvider, AdServerMockSettings};
-        use trusted_server_core::auction::orchestrator::AuctionOrchestrator;
-        use trusted_server_core::auction::types::{
-            AdFormat, AdSlot, AuctionContext, AuctionRequest, MediaType, PublisherInfo, UserInfo,
-        };
-        use trusted_server_core::platform::test_support::{
-            StubHttpClient, build_services_with_http_client,
-        };
-        use trusted_server_core::provider_table::ProviderList;
-        use trusted_server_core::test_support::tests::create_test_settings;
-
-        let http = Arc::new(StubHttpClient::new());
-        http.push_response(
-            200,
-            serde_json::to_vec(&serde_json::json!({
-                "seatbid": [{"seat": "upstream-seat", "bid": [{
-                    "id": "aps-bid", "impid": "fictional-slot", "price": 2.0,
-                    "w": 300, "h": 250,
-                    "ext": {"creativeurl": "https://creative.example/render", "tagtype": "iframe"}
-                }]}]
-            }))
-            .expect("should serialize APS response"),
-        );
-        http.push_response(
-            200,
-            serde_json::to_vec(&serde_json::json!({
-                "seatbid": [{"seat": "aps_instance", "bid": [{
-                    "id": "adserver-aps", "impid": "fictional-slot", "price": 2.0,
-                    "adm": "ignored", "w": 300, "h": 250, "crid": "aps-creative"
-                }]}]
-            }))
-            .expect("should serialize adserver response"),
-        );
-        let services = build_services_with_http_client(Arc::clone(&http) as Arc<_>);
-
-        let mut settings = create_test_settings();
-        settings.auction.enabled = true;
-        settings.auction.timeout_ms = 777;
-        let serde_json::Value::Object(aps) = serde_json::json!({
-            "implementation": "auction.aps",
-            "endpoint": "https://aps.example/e/pb/bid",
-            "account_id": "example-account",
-            "timeout_ms": 1000,
-            "routing": "all_eligible",
-        }) else {
-            panic!("should build the APS table");
-        };
-        settings.demand = ProviderList::new(
-            vec!["aps_instance".to_string()],
-            BTreeMap::from([("aps_instance".to_string(), aps)]),
-        );
-        let plan = trusted_server_core::auction::compile_auction_plan_with(&settings, &builders())
-            .expect("should compile the planned APS auction");
-        let adserver = AdServerMockProvider::new(
-            "adserver_mock",
-            AdServerMockSettings {
-                endpoint: "https://adserver.example/mediate".to_string(),
-                timeout_ms: 500,
-                ..AdServerMockSettings::default()
-            },
-        );
-        let orchestrator = AuctionOrchestrator::from_plan(Arc::new(plan), Some(Arc::new(adserver)));
-        let request = AuctionRequest {
-            id: "fictional-auction".to_string(),
-            slots: vec![AdSlot {
-                id: "fictional-slot".to_string(),
-                formats: vec![AdFormat {
-                    media_type: MediaType::Banner,
-                    width: 300,
-                    height: 250,
-                }],
-                floor_price: Some(1.0),
-                targeting: HashMap::new(),
-                bidders: HashMap::new(),
-            }],
-            publisher: PublisherInfo {
-                domain: "publisher.example".to_string(),
-                page_url: Some("https://publisher.example/article".to_string()),
-            },
-            user: UserInfo {
-                id: None,
-                consent: None,
-                eids: None,
-            },
-            device: None,
-            site: None,
-            context: HashMap::new(),
-        };
-        let inbound = http::Request::new(edgezero_core::body::Body::empty());
-        let context = AuctionContext {
-            settings: &settings,
-            request: &inbound,
-            timeout_ms: 777,
-            transport_timeout_ms: 777,
-            provider_responses: None,
-            services: &services,
-        };
-
-        let result = orchestrator
-            .run_auction(&request, &context)
-            .await
-            .expect("should decide planned APS bid");
-
-        let provider_bid = &result.provider_responses[0].bids[0];
-        assert_eq!(result.provider_responses[0].provider, "aps_instance");
-        assert_eq!(provider_bid.returned_seat.as_deref(), Some("upstream-seat"));
-        assert_eq!(provider_bid.bidder, "aps");
-        let winner = &result.winning_bids["fictional-slot"];
-        assert_eq!(winner.returned_seat.as_deref(), Some("upstream-seat"));
-        assert_eq!(winner.bidder, "aps");
-        assert!(winner.renderer.is_some());
-        assert!(winner.creative.is_none());
-        assert_eq!(
-            result
-                .adserver_response
-                .as_ref()
-                .map(|response| response.provider.as_str()),
-            Some("adserver_mock")
-        );
-    }
-
-    /// Every crate outside core says who maintains it, in the
-    /// `[package.metadata.maintainers]` table of its manifest. The manifests
-    /// are read from the source tree, which a Wasm test run cannot reach.
-    #[cfg(not(target_arch = "wasm32"))]
-    #[test]
-    fn every_crate_outside_core_declares_its_maintainers() {
-        const STATUSES: [&str; 3] = ["vendor owned", "seeking vendor owner", "project owned"];
-
-        let crates = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
-            .parent()
-            .expect("should have the crates folder above this crate");
-        let mut manifests = vec![crates.join("trusted-server-modules").join("Cargo.toml")];
-        for entry in std::fs::read_dir(crates).expect("should list the crates folder") {
-            let type_folder = entry.expect("should read a folder entry").path();
-            // A crate directly under `crates/` is core, an adapter or a tool.
-            // A module crate is one folder further down, under its type.
-            if !type_folder.is_dir() || type_folder.join("Cargo.toml").is_file() {
-                continue;
-            }
-            for entry in std::fs::read_dir(&type_folder).expect("should list a type folder") {
-                let manifest = entry
-                    .expect("should read a folder entry")
-                    .path()
-                    .join("Cargo.toml");
-                if manifest.is_file() {
-                    manifests.push(manifest);
-                }
-            }
-        }
-        assert!(
-            manifests.len() > 20,
-            "should find the module crates, found {}",
-            manifests.len()
-        );
-
-        for manifest in manifests {
-            let text = std::fs::read_to_string(&manifest).expect("should read a manifest");
-            let Some((_, after)) = text.split_once("[package.metadata.maintainers]") else {
-                panic!("{} should declare its maintainers", manifest.display());
-            };
-            let table = after.split("\n[").next().unwrap_or_default();
-            let value = |key: &str| {
-                table.lines().find_map(|line| {
-                    line.strip_prefix(key)?
-                        .trim_start()
-                        .strip_prefix('=')?
-                        .trim()
-                        .strip_prefix('"')?
-                        .strip_suffix('"')
-                })
-            };
-            assert!(
-                value("owner").is_some_and(|owner| !owner.is_empty()),
-                "{} should name an owner",
-                manifest.display()
-            );
-            let status = value("status").unwrap_or_default();
-            assert!(
-                STATUSES.contains(&status),
-                "{} should state one of {STATUSES:?}, and states `{status}`",
-                manifest.display()
-            );
-        }
-    }
-}
diff --git a/docs/guide/ad-serving.md b/docs/guide/ad-serving.md
index 978a97a595..c863685bc9 100644
--- a/docs/guide/ad-serving.md
+++ b/docs/guide/ad-serving.md
@@ -28,9 +28,9 @@ implementation it runs. The shipped implementations are:
 - `auction.aps` for the APS OpenRTB contract and typed renderer response.
 
 Browser-visible bidder codes are mapped separately under
-`[auction.bidders.<id>]`. `ad-server.mock` is the only shipped ad server; it
-is optional, selected by `[ad-server] module = "mock"` and configured under
-`[ad-server.mock]`.
+`[auction.bidders.<id>]`. `ad-server.iabtl` is the only shipped ad server; it
+is optional, selected by `[ad-server] module = "iabtl"` and configured under
+`[ad-server.iabtl]`.
 
 ```toml
 [auction]
diff --git a/docs/guide/api-reference.md b/docs/guide/api-reference.md
index b4ab8e3c61..d9ba13c239 100644
--- a/docs/guide/api-reference.md
+++ b/docs/guide/api-reference.md
@@ -1101,7 +1101,7 @@ predicates below, `named` means a section selects the integration's module.
 
 | Integration          | Registration predicate                                              | HTTP routes                                       |
 | -------------------- | ------------------------------------------------------------------- | ------------------------------------------------- |
-| `adserver_mock`      | `[ad-server] module = "mock"`                                       | None                                              |
+| `adserver_mock`      | `[ad-server] module = "iabtl"`                                      | None                                              |
 | `aps`                | `demand implementation=auction.aps;rendering_mode=publisher_native` | None                                              |
 | `aps`                | `demand implementation=auction.aps;rendering_mode=trusted_server`   | `GET /integrations/aps/renderer`                  |
 | `creative`           | `always`                                                            | None                                              |
diff --git a/docs/guide/auction-orchestration.md b/docs/guide/auction-orchestration.md
index 34b2f4cc4a..9f0c45b28e 100644
--- a/docs/guide/auction-orchestration.md
+++ b/docs/guide/auction-orchestration.md
@@ -81,7 +81,7 @@ sequenceDiagram
     Orch->>Orch: Detect strategy<br/>ad server? parallel_adserver : parallel_only
     deactivate TS
 
-    Note over Orch: Strategy determined by config:<br/>[ad-server]<br/>module = "mock" → parallel_adserver<br/>No [ad-server] → parallel_only
+    Note over Orch: Strategy determined by config:<br/>[ad-server]<br/>module = "iabtl" → parallel_adserver<br/>No [ad-server] → parallel_only
   end
 
   %% === Parallel Provider Execution ===
@@ -237,7 +237,7 @@ Three demand implementations ship in this repository:
 Each `[demand.<name>]` table is one instance of the shared OpenRTB path.
 Several tables may name the same implementation or endpoint and stay distinct
 through their names, which is what the optional `implementation` line is for.
-The `ad-server.mock` ad server is selected the same way, by
+The `ad-server.iabtl` ad server is selected the same way, by
 `[ad-server] module`, and supplies an ad server implementation rather than a
 demand one. See [Configuration Rules](/guide/configuration-rules) for the
 syntax every type shares.
@@ -312,9 +312,9 @@ account_id = "example-aps-account"
 module = "pbs_main"
 
 [ad-server]
-module = "mock"
+module = "iabtl"
 
-[ad-server.mock]
+[ad-server.iabtl]
 endpoint = "https://adserver.example.com/decide"
 timeout_ms = 500
 ```
@@ -456,9 +456,9 @@ An external decision service that receives decoded-price demand responses and pe
 
 ```toml
 [ad-server]
-module = "mock"
+module = "iabtl"
 
-[ad-server.mock]
+[ad-server.iabtl]
 endpoint = "https://adserver.example.com/decide"
 timeout_ms = 500
 price_floor = 0.50
@@ -741,9 +741,9 @@ allow_script_creatives = false
 module = "pbs_main"
 
 [ad-server]
-module = "mock"
+module = "iabtl"
 
-[ad-server.mock]
+[ad-server.iabtl]
 endpoint = "https://adserver.example.com/decide"
 timeout_ms = 500
 
diff --git a/docs/guide/auction-testing.md b/docs/guide/auction-testing.md
index b433b24b95..db4d033920 100644
--- a/docs/guide/auction-testing.md
+++ b/docs/guide/auction-testing.md
@@ -46,7 +46,7 @@ Check the response and logs for these invariants:
   another demand source's bidder parameters;
 - a failure local to one demand source does not fabricate bids;
 - with no ad server, the orchestrator selects the highest valid bid per slot;
-- with `[ad-server] module = "mock"`, the configured ad server owns
+- with `[ad-server] module = "iabtl"`, the configured ad server owns
   final selection; and
 - APS winners use `ext.trusted_server.renderer` rather than raw `adm`.
 
diff --git a/docs/guide/configuration-rules.md b/docs/guide/configuration-rules.md
index 902965fa25..28a71189cc 100644
--- a/docs/guide/configuration-rules.md
+++ b/docs/guide/configuration-rules.md
@@ -53,9 +53,9 @@ setting = "value"
 | `device`            | one               | `module`, a string | `builtin` (the default), `fastly`, or an integration that supplies device signals                       |
 | `permission-signal` | several, in order | `modules`, a list  | `gpc`, `gpp`, `us-privacy`, `tcf`                                                                       |
 | `demand`            | several           | `modules`, a list  | `auction-protocol.openrtb`, `auction.prebid-server`, `auction.aps`                                      |
-| `ad-server`         | one               | `module`, a string | `mock`                                                                                                  |
+| `ad-server`         | one               | `module`, a string | `iabtl`                                                                                                 |
 | `robots-txt`        | several, in order | `modules`, a list  | `refuse_all`, `allow_all`, or an integration that supplies robots.txt rules                             |
-| `ads-txt`           | several           | `modules`, a list  | `sellers`                                                                                               |
+| `ads-txt`           | several           | `modules`, a list  | `iabtl`                                                                                                 |
 | `analytics`         | one               | `module`, a string | `tinybird`                                                                                              |
 | `cmp`               | one               | `module`, a string | `didomi`, `sourcepoint`, `osano`                                                                        |
 | `tag`               | several           | `modules`, a list  | `google-tag-manager`                                                                                    |
@@ -67,7 +67,7 @@ setting = "value"
 | `auction`           | several           | `modules`, a list  | `prebid`, `testing.testlight`                                                                           |
 | `proxy`             | several           | `modules`, a list  | `js_asset_proxy`                                                                                        |
 
-`auction-protocol.openrtb`, `auction.prebid-server`, `auction.aps` and `ad-server.mock` supply implementations
+`auction-protocol.openrtb`, `auction.prebid-server`, `auction.aps` and `ad-server.iabtl` supply implementations
 only. No module section selects them.
 
 A module that an integration supplies needs that integration selected in the
@@ -251,9 +251,9 @@ timeout_ms = 1200                          # this demand source only
 consent_forwarding = "both"
 
 [ad-server]
-module = "mock"
+module = "iabtl"
 
-[ad-server.mock]
+[ad-server.iabtl]
 endpoint = "https://adserver.example.com/decide"
 timeout_ms = 500
 
@@ -296,19 +296,21 @@ endpoint = "https://house.example.com/openrtb2/auction"
 
 ## Moving from the previous layout
 
-| Previous                                                                             | Now                                                                                                |
-| ------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------- |
-| `[integrations.<id>]` with `enabled = true`                                          | the module in the section of its type, and `[<type>.<name>]` only for settings                     |
-| `[ec.providers.<name>]`                                                              | `[ec.<name>]`                                                                                      |
-| `[permission_signal] sources`                                                        | `[permission-signal] modules`                                                                      |
-| `host-signals`, `client-fixed`, `gpp-sale-opt-out`, `gpp_sale_opt_out`, `us_privacy` | `host_signals`, `client_fixed`, `gpp`, `us-privacy`                                                |
-| `[auction.providers.<id>]` with `protocol`, `profile` and `profile_config`           | `[demand] modules` and `[demand.<name>]`, with `implementation` and the settings flat in the table |
-| `profile = "standard"`                                                               | `implementation = "auction-protocol.openrtb"`                                                      |
-| `profile = "prebid-server"` and `profile = "aps"`                                    | `implementation = "auction.prebid-server"` and `implementation = "auction.aps"`                    |
-| `[auction] mediator = "adserver_mock"` and `[integrations.adserver_mock]`            | `[ad-server] module = "mock"` and `[ad-server.mock]`                                               |
-| `[tinybird]` with `enabled = true`                                                   | `[analytics] module = "tinybird"` and `[analytics.tinybird]`                                       |
-| `[integrations.aps] rendering_mode`                                                  | `rendering_mode` in the `[demand.<name>]` table of the `auction.aps` implementation                |
-| `[debug.auction_html_comment_options] include_mediator_response`                     | `include_adserver_response`                                                                        |
+| Previous                                                                                      | Now                                                                                                |
+| --------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
+| `[integrations.<id>]` with `enabled = true`                                                   | the module in the section of its type, and `[<type>.<name>]` only for settings                     |
+| `[ec.providers.<name>]`                                                                       | `[ec.<name>]`                                                                                      |
+| `[permission_signal] sources`                                                                 | `[permission-signal] modules`                                                                      |
+| `host-signals`, `client-fixed`, `gpp-sale-opt-out`, `gpp_sale_opt_out`, `us_privacy`          | `host_signals`, `client_fixed`, `gpp`, `us-privacy`                                                |
+| `[auction.providers.<id>]` with `protocol`, `profile` and `profile_config`                    | `[demand] modules` and `[demand.<name>]`, with `implementation` and the settings flat in the table |
+| `profile = "standard"`                                                                        | `implementation = "auction-protocol.openrtb"`                                                      |
+| `profile = "prebid-server"` and `profile = "aps"`                                             | `implementation = "auction.prebid-server"` and `implementation = "auction.aps"`                    |
+| `[auction] mediator = "adserver_mock"` and `[integrations.adserver_mock]`                     | `[ad-server] module = "iabtl"` and `[ad-server.iabtl]`                                             |
+| `[ad-server] module = "mock"` and `[ad-server.mock]`, and `implementation = "ad-server.mock"` | `[ad-server] module = "iabtl"` and `[ad-server.iabtl]`, and `implementation = "ad-server.iabtl"`   |
+| `[ads-txt] modules = ["sellers"]`, `[ads-txt.sellers]` and `ads-txt.sellers` in `[[fetch]]`   | `[ads-txt] modules = ["iabtl"]`, `[ads-txt.iabtl]` and `ads-txt.iabtl` in `[[fetch]]`              |
+| `[tinybird]` with `enabled = true`                                                            | `[analytics] module = "tinybird"` and `[analytics.tinybird]`                                       |
+| `[integrations.aps] rendering_mode`                                                           | `rendering_mode` in the `[demand.<name>]` table of the `auction.aps` implementation                |
+| `[debug.auction_html_comment_options] include_mediator_response`                              | `include_adserver_response`                                                                        |
 
 The word mediator is gone with it. It is "ad server" in prose and `ad-server`
 in configuration, and the auction response metadata that read
diff --git a/docs/guide/configuration.md b/docs/guide/configuration.md
index 7d3758a9d0..eb974dd55c 100644
--- a/docs/guide/configuration.md
+++ b/docs/guide/configuration.md
@@ -1412,11 +1412,11 @@ it passes through untouched.
 
 ### `[ads-txt]`
 
-| Field     | Type          | Required | Description                                                                       |
-| --------- | ------------- | -------- | --------------------------------------------------------------------------------- |
-| `modules` | Array[String] | Yes      | What adds lines to the file. `sellers` writes the lines `[ads-txt.sellers]` gives |
+| Field     | Type          | Required | Description                                                                   |
+| --------- | ------------- | -------- | ----------------------------------------------------------------------------- |
+| `modules` | Array[String] | Yes      | What adds lines to the file. `iabtl` writes the lines `[ads-txt.iabtl]` gives |
 
-### `[ads-txt.sellers]`
+### `[ads-txt.iabtl]`
 
 | Field   | Type          | Required | Description                                                                                                                                                         |
 | ------- | ------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -1439,15 +1439,15 @@ written into the file or make it.
 
 ```toml
 [ads-txt]
-modules = ["sellers"]
+modules = ["iabtl"]
 
-[ads-txt.sellers]
+[ads-txt.iabtl]
 lines = ["ssp.example, 12345, DIRECT, f08c47fec0942fa0", "CONTACT=ads@publisher.example"]
 
 [[fetch]]
 media_type = "text/plain"
 path = "/ads.txt"
-middleware = ["ads-txt.sellers"]
+middleware = ["ads-txt.iabtl"]
 ```
 
 ## Shared Settings
@@ -2268,7 +2268,7 @@ refuses startup too, as does a section that selects nothing, so a table left
 behind after a module is switched off is caught rather than sitting unread.
 
 `auction-protocol.openrtb`, `auction.prebid-server`, `auction.aps` and
-`ad-server.mock` supply demand and ad server implementations only. They are
+`ad-server.iabtl` supply demand and ad server implementations only. They are
 not page integrations, so a section that names one refuses startup like any
 name no module supplies. Their settings live in `[demand.<name>]` and
 `[ad-server.<name>]`. `loading-cache.51degrees` supplies a loading cache
@@ -2421,7 +2421,7 @@ generated configuration places it in.
 | `ad-tag.google`               | `[[fetch]]` | Writes the `tsjs.adInit` bootstrap into the head and, when `rewrite_script` is set, points a `src` or `href` that is the GPT script's address at `/integrations/gpt/script`                                                                                                                                                                                       |
 | `ad-tag.google.loader`        | `[[serve]]` | Writes the loader tag into the head, after the bootstrap, when `write_loader` is set, for a reader whose permissions allow storage on the device                                                                                                                                                                                                                  |
 | `ad-tag.google.diagnostics`   | `[[serve]]` | For a request that activated diagnostics, writes the bootstrap ahead of the script bundle and the tag that loads the diagnostics module straight after it                                                                                                                                                                                                         |
-| `ads-txt.sellers`             | `[[fetch]]` | Writes the lines `[ads-txt.sellers]` gives at the end of the publisher's `ads.txt`, on `text/plain` alone                                                                                                                                                                                                                                                         |
+| `ads-txt.iabtl`               | `[[fetch]]` | Writes the lines `[ads-txt.iabtl]` gives at the end of the publisher's `ads.txt`, on `text/plain` alone                                                                                                                                                                                                                                                           |
 | `headers.geo`                 | `[[serve]]` | Writes the location the request resolved as the `x-geo-*` response headers, or `x-geo-info-available: false` where none is known. `[headers] modules = ["geo"]` selects it                                                                                                                                                                                        |
 | `robots_txt`                  | `[[fetch]]` | Makes the `robots.txt` that `[robots-txt]` describes, in place of whatever the origin answers, on `text/plain` and at `/robots.txt` alone                                                                                                                                                                                                                         |
 | `service_version`             | `[[serve]]` | Writes `X-TS-Version`, the git version the build compiled in, and `X-TS-Service-Version`, the platform's version number of the service, when each is known. Core supplies it, so no section selects it                                                                                                                                                            |
@@ -3039,9 +3039,9 @@ allow_script_creatives = false
 module = "pbs_main"
 
 [ad-server]
-module = "mock"
+module = "iabtl"
 
-[ad-server.mock]
+[ad-server.iabtl]
 endpoint = "https://adserver.example.com/decide"
 timeout_ms = 500
 ```
@@ -3090,8 +3090,8 @@ applies floors locally. With one configured, normalized demand responses are
 sent to it, and Trusted Server falls back to local ranking when the ad server
 cannot run.
 
-The one implementation this repository ships is `ad-server.mock`, written
-`mock` in `[ad-server]`, for
+The one implementation this repository ships is `ad-server.iabtl`, written
+`iabtl` in `[ad-server]`, for
 development and testing.
 
 | Setting                | Required | Default | Description                                                         |
@@ -3103,13 +3103,13 @@ development and testing.
 
 ```toml
 [ad-server]
-module = "mock"
+module = "iabtl"
 
-[ad-server.mock]
+[ad-server.iabtl]
 endpoint = "https://adserver.example.com/decide"
 timeout_ms = 500
 
-[ad-server.mock.context_query_params]
+[ad-server.iabtl.context_query_params]
 example_segments = "segments"
 ```
 
diff --git a/docs/guide/integration-guide.md b/docs/guide/integration-guide.md
index cce976ce04..45ae12bb6e 100644
--- a/docs/guide/integration-guide.md
+++ b/docs/guide/integration-guide.md
@@ -397,7 +397,7 @@ and core never names the vendor. The crates in this repository sit under
 `crates/<type>/<vendor>/`, and a vendor's crate can equally live in a
 repository of its own.
 
-`crates/testing/seam-probe` is the worked example. It is a test fixture rather
+`crates/testing/iabtl` is the worked example. It is a test fixture rather
 than something to deploy, and it exercises every part of the seam from a
 vendor crate's position. The round-trip tests in
 `crates/trusted-server-adapter-axum/tests/seam_probe.rs` drive each part
@@ -408,23 +408,24 @@ through the Axum adapter, and the Fastly adapter carries the same round trip.
 The crate hands out an `IntegrationBuilder`, which names the integration and
 points at the functions that do the work.
 
-| Part                                          | Purpose                                                                                                                                                                                                   |
-| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Id                                            | Names the integration in its browser module, in diagnostics and in the prefix `/integrations/<id>/` of its proxy routes, unless a route takes [a path of its own](#serving-an-endpoint-from-a-module)     |
-| Source                                        | The crate or package name, reported when two builders claim one id, so an operator can tell which crates collided                                                                                         |
-| Build function                                | Reads `Settings` and returns the registration. It is called only when a section selects the module                                                                                                        |
-| Validate function                             | The integration's own deploy rules. It runs for every builder, selected or not                                                                                                                            |
-| `.with_module_name("<type>.<name>")`          | The name a section selects the module by, which is the crate's path under `crates/` with `.` between the parts. `module_name!()` derives it from the crate's folder                                       |
-| `.with_request_preparer(...)`                 | Optional. Runs before routing, once for a request, whether or not the module is selected                                                                                                                  |
-| `.with_response_finalizer(...)`               | Optional. Finishes the response the page path returns, from what the module's request hooks left for the request                                                                                          |
-| `.with_auction_token()`                       | Optional. Declares that the module's browser script reads the token an auction publishes with its winning bids, which is made only when a selected module reads one                                       |
-| `.with_secret_settings(...)`                  | Optional. Lists the settings in the module's own table that hold the name of a secret, so each is looked up as the settings load                                                                          |
-| `.with_plan_registration(...)`                | Optional. Registers the module from the compiled auction plan, for a module whose page support follows what the plan selects. It runs whether or not a section selects the module, and its hooks go first |
-| `.with_plan_validator(...)`                   | Optional. Checks the module's settings against the compiled auction plan, when a deployment is validated and as the settings load                                                                         |
-| `.with_demand(...)` and `.with_adserver(...)` | Optional. Registers an auction implementation that `[demand]` or `[ad-server]` can name. A crate that supplies nothing else starts from `IntegrationBuilder::implementations(...)`                        |
-| `.with_loading_cache(...)`                    | Optional. Offers the loading cache the crate supplies, which a feature selects by the module's name in its `[cache.<name>]` table. An adapter takes the selections with `loading_caches_from`             |
-| `.with_cache_features(...)`                   | Optional. Declares the caches the module loads through, by name, each selected in its own `[cache.<name>]` table as `[cache.robots-txt]` is. A name core or another builder declares is refused           |
-| `.with_shared_settings(...)`                  | Optional. Runs the builder when its vendor's `[shared.<vendor>]` table is present, for a vendor whose modules all read that one table. A builder the table runs is selected by no section                 |
+| Part                                          | Purpose                                                                                                                                                                                                                                                              |
+| --------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                                            | Names the integration in its browser module, in diagnostics and in the prefix `/integrations/<id>/` of its proxy routes, unless a route takes [a path of its own](#serving-an-endpoint-from-a-module)                                                                |
+| Source                                        | The crate or package name, reported when two builders claim one id, so an operator can tell which crates collided                                                                                                                                                    |
+| Build function                                | Reads `Settings` and returns the registration. It is called only when a section selects the module                                                                                                                                                                   |
+| Validate function                             | The integration's own deploy rules. It runs for every builder, selected or not                                                                                                                                                                                       |
+| `.with_module_name("<type>.<name>")`          | The name a section selects the module by, which is the crate's path under `crates/` with `.` between the parts. `module_name!()` derives it from the crate's folder                                                                                                  |
+| `.with_request_preparer(...)`                 | Optional. Runs before routing, once for a request, whether or not the module is selected                                                                                                                                                                             |
+| `.with_response_finalizer(...)`               | Optional. Finishes the response the page path returns, from what the module's request hooks left for the request                                                                                                                                                     |
+| `.with_auction_token()`                       | Optional. Declares that the module's browser script reads the token an auction publishes with its winning bids, which is made only when a selected module reads one                                                                                                  |
+| `.with_secret_settings(...)`                  | Optional. Lists the settings in the module's own table that hold the name of a secret, so each is looked up as the settings load                                                                                                                                     |
+| `.with_middleware(...)`                       | Optional. Describes the page changes the registration supplies, each with the phase and the media type an entry names it for, so `ts audit` places them without reading the module. The registry refuses a registration whose middleware contradicts the description |
+| `.with_plan_registration(...)`                | Optional. Registers the module from the compiled auction plan, for a module whose page support follows what the plan selects. It runs whether or not a section selects the module, and its hooks go first                                                            |
+| `.with_plan_validator(...)`                   | Optional. Checks the module's settings against the compiled auction plan, when a deployment is validated and as the settings load                                                                                                                                    |
+| `.with_demand(...)` and `.with_adserver(...)` | Optional. Registers an auction implementation that `[demand]` or `[ad-server]` can name. A crate that supplies nothing else starts from `IntegrationBuilder::implementations(...)`                                                                                   |
+| `.with_loading_cache(...)`                    | Optional. Offers the loading cache the crate supplies, which a feature selects by the module's name in its `[cache.<name>]` table. An adapter takes the selections with `loading_caches_from`                                                                        |
+| `.with_cache_features(...)`                   | Optional. Declares the caches the module loads through, by name, each selected in its own `[cache.<name>]` table as `[cache.robots-txt]` is. A name core or another builder declares is refused                                                                      |
+| `.with_shared_settings(...)`                  | Optional. Runs the builder when its vendor's `[shared.<vendor>]` table is present, for a vendor whose modules all read that one table. A builder the table runs is selected by no section                                                                            |
 
 ```rust
 pub fn module_name() -> &'static str {
@@ -456,8 +457,8 @@ status = "vendor owned"
 `status` is `vendor owned` once the vendor has adopted the crate,
 `seeking vendor owner` while the Trusted Server maintainers hold it for a
 vendor, and `project owned` for a crate that is the project's own, such as a
-test module. A test in `crates/trusted-server-modules` fails for a crate in
-this repository that leaves the declaration out.
+test module. A test of the Axum adapter fails for a crate in this repository
+that leaves the declaration out.
 
 ### What a registration can declare
 
@@ -521,8 +522,8 @@ the request's cookies.
 
 The registry builds only the modules a section selects, so the module that
 supplies one of these has to be selected in its section as well. The probe
-is run with `[testing] modules = ["seam-probe"]` and its geo module is
-selected with `[geo] module = "testing.seam-probe"`. A `[geo] module` or
+is run with `[testing] modules = ["iabtl"]` and its geo module is
+selected with `[geo] module = "testing.iabtl"`. A `[geo] module` or
 `[device] module` naming something no running module supplies refuses
 startup. The message lists the modules of that type the deployment runs, and
 says when the name is a module no section selects or one that supplies no
@@ -853,17 +854,43 @@ The round-trip tests in
 `crates/trusted-server-adapter-fastly/src/app/seam_probe_tests.rs` drive the
 probe through the Fastly adapter under Viceroy.
 
-### The modules a stock build ships
-
-`crates/trusted-server-modules` lists the modules a stock build ships from
-crates of their own, in the order their request hooks run. Every adapter
-builds its state with that list followed by the builders a deployment added,
-and loads its settings against the same list. The `ts` tool registers it for
-deploy validation. A module joins a stock build by adding its crate and its
-builder to that list, in the place its request hooks should run. The order of
-the list does not order page changes, which run in the order an entry names
-them. Offering a module does not run it, because the registry builds a module
-only when a section of the settings selects it.
+### The modules an adapter links
+
+Each adapter lists the module builders it links in its own `app.rs`, in the
+order their request hooks run, the way it lists the permission signal schemes
+it links. It builds its state with that list followed by the builders a
+deployment added, and loads its settings against the same list. The `ts` tool
+lists the builders it links the same way, for deploy validation and for the
+configuration `ts audit` writes. A module joins a build by adding its crate
+and its builder to the list of each adapter that links it, in the place its
+request hooks should run, and a deployment that wants a different set links a
+different set. The order of the list does not order page changes, which run
+in the order an entry names them. Offering a module does not run it, because
+the registry builds a module only when a section of the settings selects it.
+
+A module describes the page changes it supplies on its builder, with
+`.with_middleware(...)`, each as a `SuppliedMiddleware` naming the middleware,
+the phase an entry names it in and the media type the entry covers. A
+middleware that runs in either phase is described in the one a generated
+configuration places it in. `ts audit` asks
+`trusted_server_core::integrations::supplied_middleware` for what the builders
+it links describe, in the order the registry registers them, and writes the
+entries from that, so a module's page changes are placed without a table
+anywhere else. The registry refuses a registration whose middleware
+contradicts the description.
+
+```rust
+const SUPPLIED_MIDDLEWARE: &[SuppliedMiddleware] = &[
+    SuppliedMiddleware::on_html(MODULE, MiddlewarePhase::Fetch),
+    SuppliedMiddleware::on_html(TAG_MIDDLEWARE, MiddlewarePhase::Serve),
+];
+
+pub fn builder() -> IntegrationBuilder {
+    IntegrationBuilder::new(ID, env!("CARGO_PKG_NAME"), register, validate)
+        .with_module_name(MODULE)
+        .with_middleware(SUPPLIED_MIDDLEWARE)
+}
+```
 
 ### Giving the deployment its prefixes
 
diff --git a/docs/guide/integrations-overview.md b/docs/guide/integrations-overview.md
index eff502cdbb..a8b8744363 100644
--- a/docs/guide/integrations-overview.md
+++ b/docs/guide/integrations-overview.md
@@ -27,7 +27,7 @@ their operational procedures.
 
 | Integration                                                    | Operational status | Selected by                                               | Registration       | Browser loading |
 | -------------------------------------------------------------- | ------------------ | --------------------------------------------------------- | ------------------ | --------------- |
-| [`adserver_mock`](/guide/integrations/adserver_mock)           | development        | `[ad-server] module = "mock"`                             | ad server          | none            |
+| [`adserver_mock`](/guide/integrations/adserver_mock)           | development        | `[ad-server] module = "iabtl"`                            | ad server          | none            |
 | [`aps`](/guide/integrations/aps)                               | development        | a `[demand]` source with `implementation = "auction.aps"` | auction plan       | none            |
 | [`creative`](/guide/creative-processing)                       | development        | nothing, it always runs                                   | browser capability | bundled         |
 | [`datadome`](/guide/integrations/datadome)                     | development        | `[bot-protection] module = "datadome"`                    | settings builder   | bundled         |
diff --git a/docs/guide/integrations/adserver_mock.md b/docs/guide/integrations/adserver_mock.md
index c9ecad0d02..3399ddd9a7 100644
--- a/docs/guide/integrations/adserver_mock.md
+++ b/docs/guide/integrations/adserver_mock.md
@@ -1,10 +1,10 @@
 # Ad Server Mock
 
-`ad-server.mock` is a development ad server for the auction orchestrator. It
+`ad-server.iabtl` is a development ad server for the auction orchestrator. It
 is not a demand source and does not expose an integration proxy route.
 
-Select it with `[ad-server] module = "mock"` and give it an
-`[ad-server.mock]` table. The orchestrator first gathers responses from
+Select it with `[ad-server] module = "iabtl"` and give it an
+`[ad-server.iabtl]` table. The orchestrator first gathers responses from
 the configured demand sources, then passes successful bids to the ad
 server's HTTP endpoint for final selection.
 
diff --git a/docs/guide/integrations/aps.md b/docs/guide/integrations/aps.md
index 879bd0a949..a3e6953c85 100644
--- a/docs/guide/integrations/aps.md
+++ b/docs/guide/integrations/aps.md
@@ -54,9 +54,9 @@ rendering_mode = "trusted_server"
 # inventory_page_origin = "https://www.inventory.example.com"
 
 [ad-server]
-module = "mock"
+module = "iabtl"
 
-[ad-server.mock]
+[ad-server.iabtl]
 endpoint = "https://adserver.example.com/decide"
 timeout_ms = 500
 ```
@@ -374,7 +374,7 @@ Use fictional values in source-controlled configuration and fixtures. Supply con
 ```bash
 cargo test -p trusted-server-auction-aps --target wasm32-wasip1
 cargo test-fastly auction::orchestrator
-cargo test -p trusted-server-ad-server-mock --target wasm32-wasip1
+cargo test -p trusted-server-ad-server-iabtl --target wasm32-wasip1
 
 cd crates/trusted-server-js/lib
 npx vitest run test/integrations/aps/render.test.ts test/core/auction.test.ts
diff --git a/docs/guide/onboarding.md b/docs/guide/onboarding.md
index 22411662e3..ba82dc68e2 100644
--- a/docs/guide/onboarding.md
+++ b/docs/guide/onboarding.md
@@ -85,7 +85,6 @@ See [Architecture](/guide/architecture) for component boundaries and
 | `crates/trusted-server-core/src/consent/`      | Consent extraction, decoding, and enforcement                    |
 | `crates/trusted-server-core/src/integrations/` | Integration registry and the builder a module registers with     |
 | `crates/<type>/<vendor>/`                      | One module each: a page integration or an auction implementation |
-| `crates/trusted-server-modules/`               | The modules a stock build ships, in the order their hooks run    |
 | `crates/trusted-server-js/lib/src/`            | Browser-side TypeScript and integration modules                  |
 | `crates/trusted-server-adapter-*`              | Fastly, Axum, Cloudflare, and Spin runtime entry points          |
 | `crates/trusted-server-cli/`                   | Native `ts` operator CLI                                         |
diff --git a/docs/superpowers/specs/2026-10-14-no-modules-crate-design.md b/docs/superpowers/specs/2026-10-14-no-modules-crate-design.md
new file mode 100644
index 0000000000..6fcdcaf1a4
--- /dev/null
+++ b/docs/superpowers/specs/2026-10-14-no-modules-crate-design.md
@@ -0,0 +1,101 @@
+# Design Spec: Each adapter lists the modules it links, each module describes its middleware, and the project's own modules are renamed iabtl
+
+**Status:** Proposed, 2026-10-14. Raised as pull request IABTechLab/trusted-server#1384 (from jwrosewell/trusted-server#38), for Tech Lab review.
+**Author:** 51Degrees (contributed), for Tech Lab review
+**Related specs:** `2026-10-14-source-modules-design.md`, in IABTechLab/trusted-server#1342, which replaced IABTechLab/trusted-server#1084 as the one place for every design document of the stack of pull requests listed in IABTechLab/trusted-server#777
+**Related PRs:** IABTechLab/trusted-server#1384, jwrosewell/trusted-server#38
+**Issues:** IABTechLab/trusted-server#1334
+**Last updated:** 2026-10-27
+
+> **Why this spec exists.** One crate held the list of the modules a stock build ships on every adapter's behalf, with a table saying which middleware each supplies, so a deployment that wanted a different set edited a crate that was not its own, and a module's description of itself lived in a crate that was not the module's. The same change renames the three modules the project owns itself, and those renames are the only part that changes what an operator writes in settings.
+
+## 1. Problem
+
+`crates/trusted-server-modules` listed the twenty stock module builders in hook order, and the Axum, Cloudflare, Fastly and Spin adapters, the `ts` tool and the integration tests crate each linked the whole of it. A deployment that wanted a different set of modules than the stock list had no composition of its own to write. The crate also held the table `ts audit` read to write `[[fetch]]` and `[[serve]]` entries for HTML pages, with every stock middleware's phase and media type, and the section and name each stock module is selected by. A module's page changes were therefore described twice, once by the module's registration and once by a table in another crate. One test in that crate (`the_listed_middleware_are_the_ones_the_modules_register`) kept the table in step with the stock modules' registrations, and a module a deployment added had no row in the table at all.
+
+Three modules the project owns itself also sat under names that said nothing about who maintains them, being `crates/ad-server/mock`, `crates/testing/seam-probe` and `crates/ads-txt/sellers`. A crate sits at `crates/<type>/<vendor>/`, and these three have no vendor to take a folder name from, because each names the Trusted Server maintainers as its owner, with the status `project owned`, in its manifest.
+
+## 2. Design
+
+**Each adapter lists the builders it links.** The Axum, Cloudflare, Fastly and Spin adapters each hold the list in their own `app.rs`, beside the function that lists the permission signal schemes the adapter links, and the schemes stay a separate list. `shipped_module_builders()` gives the twenty builders in the order their request hooks run, which is the order the old crate listed them, and `module_builders_with(extra)` gives the same builders followed by a deployment's own. Each adapter builds its state and loads its settings from its list in the places where it took the old crate's list. The Axum, Cloudflare and Spin adapters export both functions from their public `app` module, and the Fastly adapter, whose `app` module is private, re-exports them from the crate root. A deployment that wants a different set links a different set, and one that only adds a module hands its builder to the adapter (`run_with` on Fastly, `routes_with_registrations` on the others), which runs the builder after the listed ones.
+
+The `ts` tool lists the builders it links the same way, because it validates a deployment's settings against each module's own rules. The list is the function `linked_builders()` in `crates/trusted-server-cli/src/app_config.rs`, and the crate exports the function from its root. The integration tests crate keeps no list of its own and validates its fixture configurations against `trusted_server_adapter_axum::app::shipped_module_builders()`, on the understanding that every adapter links the same modules.
+
+A deployment with a different set also needs a `ts` tool with a matching list. No call hands `ts audit generate` another list, because the command reads `linked_builders()` directly, in `build_page_entries` and `module_section` (`crates/trusted-server-cli/src/commands/audit/generate/mod.rs`), and `run_from_env()` takes none. A deployment with a different set therefore changes `linked_builders()` in its own copy of the crate. A list registered first with `trusted_server_core::config::register_deploy_integrations`, where the first call wins, changes what the tool validates against and leaves what `ts audit generate` writes as it was.
+
+**Each module describes the middleware it supplies.** `IntegrationBuilder::with_middleware` takes the page changes a module's registration supplies, each as a `SuppliedMiddleware` naming the middleware, the phase an entry names it in and the media type the entry covers. A middleware that runs in either phase is described in the one a generated configuration places it in. The registry refuses a registration whose middleware contradicts the description, in a phase it does not run in or for a media type it does not work on, and a per-crate test proves each stock module's description is exactly what it registers. The registry leaves alone a described middleware that the registration does not supply, because a module may supply one only where its settings call for it. Every stock module registers each middleware it describes whenever the module runs.
+
+```rust
+const SUPPLIED_MIDDLEWARE: &[SuppliedMiddleware] = &[
+    SuppliedMiddleware::on_html(MODULE, MiddlewarePhase::Fetch),
+    SuppliedMiddleware::on_html(TAG_MIDDLEWARE, MiddlewarePhase::Serve),
+];
+
+pub fn builder() -> IntegrationBuilder {
+    IntegrationBuilder::new(ID, env!("CARGO_PKG_NAME"), register, validate)
+        .with_module_name(MODULE)
+        .with_middleware(SUPPLIED_MIDDLEWARE)
+}
+```
+
+**When a description is wrong.** The check runs where the registry is built, which is each adapter's state build. Deploy validation (`ts config validate` and `ts config push`) never builds the registry (`validate_settings_for_deploy_with` in `crates/trusted-server-core/src/config.rs`), so the per-crate tests are what find a description the registration contradicts before a service starts, and a running service finds it only at startup. A refusal fails the adapter's state build, so the service serves no page. Fastly, Axum and Cloudflare answer with a 500 and a generic body, Spin answers with a 503, and the refusal, naming the module, the middleware and the difference, goes to the log.
+
+**Core lists what a build supplies.** `trusted_server_core::integrations::supplied_middleware(builders)` gives every described middleware of the built-in modules and `builders`, with the integration that supplies it, in the order the registry registers them: what registers from the auction plan first, then the built-in modules, then the linked builders in their order, then core's robots.txt and service version middleware, which no builder supplies. `ts audit` asks this of the builders it links and holds no table, and finds the section a module is selected in and the name it is written under from the builder itself. The entries `ts audit` writes are for `text/html` only, so a middleware described for another media type, such as the Flight rewriter's `text/x-component` or the ads.txt module's `text/plain`, is left out.
+
+**The project's own modules take the name `iabtl`.** `iabtl` is short for IAB Tech Lab, which hosts this repository, and is the vendor folder for a module the project owns itself, as `didomi` is the vendor folder in `crates/cmp/didomi`. `crates/ad-server/mock` is `crates/ad-server/iabtl`, `crates/testing/seam-probe` is `crates/testing/iabtl` and `crates/ads-txt/sellers` is `crates/ads-txt/iabtl`, each with its maintainers named as every crate outside core names them. The packages change with the folders, from `trusted-server-ad-server-mock`, `trusted-server-integration-seam-probe` and `trusted-server-ads-txt-sellers` to `trusted-server-ad-server-iabtl`, `trusted-server-testing-iabtl` and `trusted-server-ads-txt-iabtl`. A module's name follows its folder, so the selectors a deployment writes change:
+
+| Was                                                       | Is                                                     |
+| --------------------------------------------------------- | ------------------------------------------------------ |
+| `[ad-server] module = "mock"` and `[ad-server.mock]`      | `[ad-server] module = "iabtl"` and `[ad-server.iabtl]` |
+| `implementation = "ad-server.mock"`                       | `implementation = "ad-server.iabtl"`                   |
+| `[ads-txt] modules = ["sellers"]` and `[ads-txt.sellers]` | `[ads-txt] modules = ["iabtl"]` and `[ads-txt.iabtl]`  |
+| `middleware = ["ads-txt.sellers"]`                        | `middleware = ["ads-txt.iabtl"]`                       |
+
+The seam probe is a test fixture that no deployment ships, so its renames reach only the tests and fixtures that drive it. They are:
+
+- the module `testing.seam-probe`, now `testing.iabtl`, and its serve middleware `testing.seam-probe.reader`, now `testing.iabtl.reader`
+- the shared table `[shared.seam-probe]`, now `[shared.iabtl]`
+- the declared cache `seam-probe-answers`, now `iabtl-answers`
+- the loading cache `loading-cache.seam-probe`, selected as `module = "seam-probe"`, now `loading-cache.iabtl`, selected as `module = "iabtl"`
+
+**What does not change.** A deployment that keeps the stock set and selects none of the renamed modules runs the same modules in the same order with the same settings, because the twenty builders are the old crate's in its order, apart from the ad server and ads.txt crates, which carry their new names. The permission signal schemes stay in their own list in each adapter. A list that leaves a module out makes startup refuse any section that selects it, naming the modules on offer (`check_section_selections` in `crates/trusted-server-core/src/integrations/registry.rs`). The change adds no setting and no default, and the only names that move in settings are the renames above.
+
+**For crates outside core.** `trusted-server-modules` is removed, with `builders()`, `builders_with(extra)`, `selection_of(id)`, `middleware()`, `middleware_for(ids, phase)` and `StockMiddleware`. A crate that took its list from `builders()` or `builders_with(extra)` names the crates it links instead, or takes an adapter's `shipped_module_builders()`. A crate that read the table of middleware reads `supplied_middleware(builders)` in core, and one that used `selection_of(id)` asks the builder for its `section()` and `module_name()`. The removal and the renames are listed as breaking in `CHANGELOG.md`.
+
+**Rollout.** A module's name is its folder's and has no second name, so no alias accepts both the old and the new name, and a name in settings that no linked module answers to is refused when the service starts. A deployment that selects `mock` or `sellers`, or names one of them in an `implementation` line or an entry, changes its settings and its build together. On Fastly the settings sit in a config store apart from the compiled service (`load_settings_from_config_store` in `crates/trusted-server-adapter-fastly/src/app.rs`), and `ts config push` and a deploy are separate steps. If the new settings are pushed first, the active version refuses the new names, and if the new version is activated first, that version refuses the old names, so the service serves no page until the second step is done. A deployment in that position chooses the moment, and can rehearse the pair on a staged version first with `ts deploy --staging` and `ts config push --staging` (`docs/guide/cli.md`).
+
+## 3. What is not in this change
+
+- A registry refusal of a registered middleware its builder does not describe. A description is optional, so a vendor crate that describes none is still linked and run, and `ts audit` places only what a builder describes.
+- A shared list any two adapters read. Nothing is shared by being listed, so each adapter and each deployment names the crates it links itself.
+- A way to hand `ts audit generate` a deployment's list. Section 2 gives what a deployment with a different set does instead.
+- An alias for the old module names. The rollout in section 2 gives the order of work instead.
+- The crates' own type names and log labels, which say what a module does rather than where it lives.
+- Three small changes left for a later change: different names for `IntegrationBuilder::with_middleware` and `IntegrationRegistrationBuilder::with_middleware`, the doc comments now above the wrong items (`check_described_middleware` in the registry and `SUPPLIED_MIDDLEWARE` in the seam probe), and the mention of `trusted-server-modules` in `2026-10-14-rsc-flight-middleware-design.md`.
+
+## 4. Tests
+
+- A builder describes no middleware until told, and the description is read back as given.
+- `supplied_middleware` lists what the plan registers first, then core's own, then the linked builders in order, then core's file and version middleware, with each row's phase and media type.
+- Core's robots.txt row is what the registry registers for a `[robots-txt]` section, in the listed phase and for the listed media type.
+- A description the registration contradicts is refused at startup, naming the module, the middleware and the difference, for a wrong phase and for a wrong media type, and a description the registration bears out is accepted.
+- Each stock module that supplies middleware, core's script proxy and the seam probe describe exactly what they register under their own fixture settings, in registration order.
+- Each adapter lists its builders in the order their hooks run, and `module_builders_with` puts a deployment's builders after them.
+- The Axum adapter's linked builders give what the stock list gave: no loading cache module is linked, so every feature loads through `NoLoadingCache` unless a deployment links one (`2026-10-12-loading-cache-design.md`), every page module refuses a setting it does not know, the diagnostics module's request preparer is attached, the template's entries and the guide's table name the middleware the linked modules supply in order, the documented tables validate when uncommented, deploy validation runs a module's own rules and lists its secret settings, the ad server keeps an APS winner's identities, and every crate outside core declares its maintainers.
+- `ts audit` finds a module's selection by its integration id from the builders the tool links, and writes `text/html` entries that run the selected modules' middleware in registration order.
+
+Three things have no test. The first is the five lists agreeing. Each adapter's order test, and the `ts` list's (`the_linked_modules_are_offered_in_hook_order` in `crates/trusted-server-cli/src/app_config.rs`), pins its own list against a copy of the same twenty names, so the five lists agree today, but nothing compares one list with another, and the integration tests crate validates its fixtures against the Axum adapter's list alone. Adding a module takes five edits and a missed one passes every test, so a test that gives the same ids in the same order from all five lists is missing. The second is the registry accepting a described middleware that the registration leaves out, because no test has a registration omit a middleware its builder describes. The third is `ts audit` leaving out a middleware described for another media type, because the draft test that checks the entries selects `gpt`, `datadome`, `didomi` and `google_tag_manager`, whose middleware are all described for `text/html`, and `build_page_entries` has no direct test.
+
+## Revision record
+
+| Date       | Change                                                                                                                                                                                                                                                                                                                                                                                                                |
+| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 2026-10-14 | First draft.                                                                                                                                                                                                                                                                                                                                                                                                          |
+| 2026-10-15 | Fixes from review round 1. The other users of the old crate, the test that kept its table in step, the renamed packages and the seam probe's names, the adapters and the list functions, what does not change, the startup refusal, the rollout of the renamed selectors, what `ts audit` reads and writes, the missing tests, `iabtl` and the stack defined, the renames in the title, and the pull requests raised. |
+| 2026-10-15 | Fixes from review round 2. The claimed test for the media types `ts audit` writes, the three changes left for a later change, and the changelog entries that still named the removed crate.                                                                                                                                                                                                                           |
+| 2026-10-27 | The Axum adapter's tests in section 4 say that its linked builders include no loading cache module, so every feature loads through `NoLoadingCache` unless a deployment links one (`2026-10-12-loading-cache-design.md`), where they said a feature selects the stock loading cache by name.                                                                                                                          |
+
+## Review log
+
+1. **Round 1, 2026-10-15.** A review in a fresh session, against `split/43-no-modules-crate` at `3ad378928`. Approved with no blocking issues. This revision closes the coverage gaps by naming the four adapters and the three list functions with where each is exported, saying what stays the same for a deployment that keeps the stock set, saying that deploy validation never builds the registry so a wrong description is refused only at startup and then stops the whole service, giving the order of work for the renamed selectors, and recording the missing test that ties the five lists together.
+2. **Round 2, 2026-10-15.** A lighter review in a fresh session, against this page at `0fdbaf5dc`, of the round 1 fixes and the new text. No blocking issues. This revision stops claiming a test for `ts audit` leaving out a middleware described for another media type and lists the gap as a third untested item, records the three small changes left for a later change, and corrects the two older changelog entries that still named the removed crate.
diff --git a/trusted-server.example.toml b/trusted-server.example.toml
index 24272a0e5e..58f996b3ee 100644
--- a/trusted-server.example.toml
+++ b/trusted-server.example.toml
@@ -250,15 +250,15 @@ pull_sync_concurrency = 3
 # for text/plain on the file's path names the middleware. Each line is a data
 # record or a variable of the ads.txt grammar, checked as the settings load.
 # [ads-txt]
-# modules = ["sellers"]
+# modules = ["iabtl"]
 
-# [ads-txt.sellers]
+# [ads-txt.iabtl]
 # lines = ["ssp.example, 12345, DIRECT, f08c47fec0942fa0"]
 
 # [[fetch]]
 # media_type = "text/plain"
 # path = "/ads.txt"
-# middleware = ["ads-txt.sellers"]
+# middleware = ["ads-txt.iabtl"]
 
 # The robots.txt the [robots-txt] section describes, made by core's own
 # middleware where this entry names it. The file replaces the origin's own
@@ -629,16 +629,16 @@ module = "pbs_main"
 
 # The ad server that picks the auction winner. With no [ad-server] selection the
 # highest bid wins. The only implementation this repository ships is
-# ad-server.mock, for development and testing, written here as mock because
+# ad-server.iabtl, for development and testing, written here as iabtl because
 # its type is this section's.
 # [ad-server]
-# module = "mock"
+# module = "iabtl"
 #
-# [ad-server.mock]
+# [ad-server.iabtl]
 # endpoint = "https://adserver.example.com/decide"
 # timeout_ms = 1000
 # Map auction context keys to decision-URL query params:
-# [ad-server.mock.context_query_params]
+# [ad-server.iabtl.context_query_params]
 # example_segments = "segments"
 
 # Server-side ad slot templates + creative-opportunity auction. Kept active.